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 >> 21) & 0x1) == 0)
3254                         {
3255                           /* 33222222222211111111110000000000
3256                              10987654321098765432109876543210
3257                              xxxxxxxxxxxxxxxxxxxxx0xx1x10x01x
3258                              msr.  */
3259                           return 955;
3260                         }
3261                       else
3262                         {
3263                           /* 33222222222211111111110000000000
3264                              10987654321098765432109876543210
3265                              xxxxxxxxxxxxxxxxxxxxx1xx1x10x01x
3266                              sysl.  */
3267                           return 973;
3268                         }
3269                     }
3270                 }
3271             }
3272           else
3273             {
3274               if (((word >> 24) & 0x1) == 0)
3275                 {
3276                   if (((word >> 25) & 0x1) == 0)
3277                     {
3278                       /* 33222222222211111111110000000000
3279                          10987654321098765432109876543210
3280                          xxxxxxxxxxxxxxxxxxxxxxxx0010x1xx
3281                          cbz.  */
3282                       return 517;
3283                     }
3284                   else
3285                     {
3286                       /* 33222222222211111111110000000000
3287                          10987654321098765432109876543210
3288                          xxxxxxxxxxxxxxxxxxxxxxxx0110x1xx
3289                          tbz.  */
3290                       return 975;
3291                     }
3292                 }
3293               else
3294                 {
3295                   if (((word >> 25) & 0x1) == 0)
3296                     {
3297                       /* 33222222222211111111110000000000
3298                          10987654321098765432109876543210
3299                          xxxxxxxxxxxxxxxxxxxxxxxx1010x1xx
3300                          cbnz.  */
3301                       return 518;
3302                     }
3303                   else
3304                     {
3305                       /* 33222222222211111111110000000000
3306                          10987654321098765432109876543210
3307                          xxxxxxxxxxxxxxxxxxxxxxxx1110x1xx
3308                          tbnz.  */
3309                       return 976;
3310                     }
3311                 }
3312             }
3313         }
3314       else
3315         {
3316           if (((word >> 25) & 0x1) == 0)
3317             {
3318               if (((word >> 28) & 0x1) == 0)
3319                 {
3320                   if (((word >> 22) & 0x1) == 0)
3321                     {
3322                       if (((word >> 23) & 0x1) == 0)
3323                         {
3324                           if (((word >> 24) & 0x1) == 0)
3325                             {
3326                               if (((word >> 29) & 0x1) == 0)
3327                                 {
3328                                   /* 33222222222211111111110000000000
3329                                      10987654321098765432109876543210
3330                                      xxxxxxxxxxxxxxxxxxxxxx00001100xx
3331                                      st4.  */
3332                                   return 355;
3333                                 }
3334                               else
3335                                 {
3336                                   /* 33222222222211111111110000000000
3337                                      10987654321098765432109876543210
3338                                      xxxxxxxxxxxxxxxxxxxxxx00001101xx
3339                                      stnp.  */
3340                                   return 741;
3341                                 }
3342                             }
3343                           else
3344                             {
3345                               if (((word >> 29) & 0x1) == 0)
3346                                 {
3347                                   if (((word >> 13) & 0x1) == 0)
3348                                     {
3349                                       if (((word >> 21) & 0x1) == 0)
3350                                         {
3351                                           /* 33222222222211111111110000000000
3352                                              10987654321098765432109876543210
3353                                              xxxxxxxxxxxxx0xxxxxxx000101100xx
3354                                              st1.  */
3355                                           return 371;
3356                                         }
3357                                       else
3358                                         {
3359                                           /* 33222222222211111111110000000000
3360                                              10987654321098765432109876543210
3361                                              xxxxxxxxxxxxx0xxxxxxx100101100xx
3362                                              st2.  */
3363                                           return 373;
3364                                         }
3365                                     }
3366                                   else
3367                                     {
3368                                       if (((word >> 21) & 0x1) == 0)
3369                                         {
3370                                           /* 33222222222211111111110000000000
3371                                              10987654321098765432109876543210
3372                                              xxxxxxxxxxxxx1xxxxxxx000101100xx
3373                                              st3.  */
3374                                           return 372;
3375                                         }
3376                                       else
3377                                         {
3378                                           /* 33222222222211111111110000000000
3379                                              10987654321098765432109876543210
3380                                              xxxxxxxxxxxxx1xxxxxxx100101100xx
3381                                              st4.  */
3382                                           return 374;
3383                                         }
3384                                     }
3385                                 }
3386                               else
3387                                 {
3388                                   /* 33222222222211111111110000000000
3389                                      10987654321098765432109876543210
3390                                      xxxxxxxxxxxxxxxxxxxxxx00101101xx
3391                                      stp.  */
3392                                   return 745;
3393                                 }
3394                             }
3395                         }
3396                       else
3397                         {
3398                           if (((word >> 29) & 0x1) == 0)
3399                             {
3400                               if (((word >> 21) & 0x1) == 0)
3401                                 {
3402                                   if (((word >> 24) & 0x1) == 0)
3403                                     {
3404                                       /* 33222222222211111111110000000000
3405                                          10987654321098765432109876543210
3406                                          xxxxxxxxxxxxxxxxxxxxx001001100xx
3407                                          st4.  */
3408                                       return 363;
3409                                     }
3410                                   else
3411                                     {
3412                                       if (((word >> 13) & 0x1) == 0)
3413                                         {
3414                                           /* 33222222222211111111110000000000
3415                                              10987654321098765432109876543210
3416                                              xxxxxxxxxxxxx0xxxxxxx001101100xx
3417                                              st1.  */
3418                                           return 383;
3419                                         }
3420                                       else
3421                                         {
3422                                           /* 33222222222211111111110000000000
3423                                              10987654321098765432109876543210
3424                                              xxxxxxxxxxxxx1xxxxxxx001101100xx
3425                                              st3.  */
3426                                           return 384;
3427                                         }
3428                                     }
3429                                 }
3430                               else
3431                                 {
3432                                   if (((word >> 13) & 0x1) == 0)
3433                                     {
3434                                       /* 33222222222211111111110000000000
3435                                          10987654321098765432109876543210
3436                                          xxxxxxxxxxxxx0xxxxxxx101x01100xx
3437                                          st2.  */
3438                                       return 385;
3439                                     }
3440                                   else
3441                                     {
3442                                       /* 33222222222211111111110000000000
3443                                          10987654321098765432109876543210
3444                                          xxxxxxxxxxxxx1xxxxxxx101x01100xx
3445                                          st4.  */
3446                                       return 386;
3447                                     }
3448                                 }
3449                             }
3450                           else
3451                             {
3452                               /* 33222222222211111111110000000000
3453                                  10987654321098765432109876543210
3454                                  xxxxxxxxxxxxxxxxxxxxxx01x01101xx
3455                                  stp.  */
3456                               return 750;
3457                             }
3458                         }
3459                     }
3460                   else
3461                     {
3462                       if (((word >> 23) & 0x1) == 0)
3463                         {
3464                           if (((word >> 24) & 0x1) == 0)
3465                             {
3466                               if (((word >> 29) & 0x1) == 0)
3467                                 {
3468                                   /* 33222222222211111111110000000000
3469                                      10987654321098765432109876543210
3470                                      xxxxxxxxxxxxxxxxxxxxxx10001100xx
3471                                      ld4.  */
3472                                   return 359;
3473                                 }
3474                               else
3475                                 {
3476                                   /* 33222222222211111111110000000000
3477                                      10987654321098765432109876543210
3478                                      xxxxxxxxxxxxxxxxxxxxxx10001101xx
3479                                      ldnp.  */
3480                                   return 742;
3481                                 }
3482                             }
3483                           else
3484                             {
3485                               if (((word >> 29) & 0x1) == 0)
3486                                 {
3487                                   if (((word >> 13) & 0x1) == 0)
3488                                     {
3489                                       if (((word >> 21) & 0x1) == 0)
3490                                         {
3491                                           /* 33222222222211111111110000000000
3492                                              10987654321098765432109876543210
3493                                              xxxxxxxxxxxxx0xxxxxxx010101100xx
3494                                              ld1.  */
3495                                           return 375;
3496                                         }
3497                                       else
3498                                         {
3499                                           /* 33222222222211111111110000000000
3500                                              10987654321098765432109876543210
3501                                              xxxxxxxxxxxxx0xxxxxxx110101100xx
3502                                              ld2.  */
3503                                           return 379;
3504                                         }
3505                                     }
3506                                   else
3507                                     {
3508                                       if (((word >> 21) & 0x1) == 0)
3509                                         {
3510                                           /* 33222222222211111111110000000000
3511                                              10987654321098765432109876543210
3512                                              xxxxxxxxxxxxx1xxxxxxx010101100xx
3513                                              ld3.  */
3514                                           return 376;
3515                                         }
3516                                       else
3517                                         {
3518                                           /* 33222222222211111111110000000000
3519                                              10987654321098765432109876543210
3520                                              xxxxxxxxxxxxx1xxxxxxx110101100xx
3521                                              ld4.  */
3522                                           return 380;
3523                                         }
3524                                     }
3525                                 }
3526                               else
3527                                 {
3528                                   /* 33222222222211111111110000000000
3529                                      10987654321098765432109876543210
3530                                      xxxxxxxxxxxxxxxxxxxxxx10101101xx
3531                                      ldp.  */
3532                                   return 746;
3533                                 }
3534                             }
3535                         }
3536                       else
3537                         {
3538                           if (((word >> 29) & 0x1) == 0)
3539                             {
3540                               if (((word >> 21) & 0x1) == 0)
3541                                 {
3542                                   if (((word >> 24) & 0x1) == 0)
3543                                     {
3544                                       /* 33222222222211111111110000000000
3545                                          10987654321098765432109876543210
3546                                          xxxxxxxxxxxxxxxxxxxxx011001100xx
3547                                          ld4.  */
3548                                       return 367;
3549                                     }
3550                                   else
3551                                     {
3552                                       if (((word >> 13) & 0x1) == 0)
3553                                         {
3554                                           /* 33222222222211111111110000000000
3555                                              10987654321098765432109876543210
3556                                              xxxxxxxxxxxxx0xxxxxxx011101100xx
3557                                              ld1.  */
3558                                           return 387;
3559                                         }
3560                                       else
3561                                         {
3562                                           /* 33222222222211111111110000000000
3563                                              10987654321098765432109876543210
3564                                              xxxxxxxxxxxxx1xxxxxxx011101100xx
3565                                              ld3.  */
3566                                           return 388;
3567                                         }
3568                                     }
3569                                 }
3570                               else
3571                                 {
3572                                   if (((word >> 13) & 0x1) == 0)
3573                                     {
3574                                       /* 33222222222211111111110000000000
3575                                          10987654321098765432109876543210
3576                                          xxxxxxxxxxxxx0xxxxxxx111x01100xx
3577                                          ld2.  */
3578                                       return 391;
3579                                     }
3580                                   else
3581                                     {
3582                                       /* 33222222222211111111110000000000
3583                                          10987654321098765432109876543210
3584                                          xxxxxxxxxxxxx1xxxxxxx111x01100xx
3585                                          ld4.  */
3586                                       return 392;
3587                                     }
3588                                 }
3589                             }
3590                           else
3591                             {
3592                               /* 33222222222211111111110000000000
3593                                  10987654321098765432109876543210
3594                                  xxxxxxxxxxxxxxxxxxxxxx11x01101xx
3595                                  ldp.  */
3596                               return 751;
3597                             }
3598                         }
3599                     }
3600                 }
3601               else
3602                 {
3603                   if (((word >> 24) & 0x1) == 0)
3604                     {
3605                       if (((word >> 29) & 0x1) == 0)
3606                         {
3607                           /* 33222222222211111111110000000000
3608                              10987654321098765432109876543210
3609                              xxxxxxxxxxxxxxxxxxxxxxxx001110xx
3610                              ldr.  */
3611                           return 754;
3612                         }
3613                       else
3614                         {
3615                           if (((word >> 10) & 0x1) == 0)
3616                             {
3617                               if (((word >> 11) & 0x1) == 0)
3618                                 {
3619                                   if (((word >> 22) & 0x1) == 0)
3620                                     {
3621                                       /* 33222222222211111111110000000000
3622                                          10987654321098765432109876543210
3623                                          xxxxxxxxxx00xxxxxxxxxx0x001111xx
3624                                          stur.  */
3625                                       return 699;
3626                                     }
3627                                   else
3628                                     {
3629                                       /* 33222222222211111111110000000000
3630                                          10987654321098765432109876543210
3631                                          xxxxxxxxxx00xxxxxxxxxx1x001111xx
3632                                          ldur.  */
3633                                       return 700;
3634                                     }
3635                                 }
3636                               else
3637                                 {
3638                                   if (((word >> 22) & 0x1) == 0)
3639                                     {
3640                                       /* 33222222222211111111110000000000
3641                                          10987654321098765432109876543210
3642                                          xxxxxxxxxx01xxxxxxxxxx0x001111xx
3643                                          str.  */
3644                                       return 675;
3645                                     }
3646                                   else
3647                                     {
3648                                       /* 33222222222211111111110000000000
3649                                          10987654321098765432109876543210
3650                                          xxxxxxxxxx01xxxxxxxxxx1x001111xx
3651                                          ldr.  */
3652                                       return 676;
3653                                     }
3654                                 }
3655                             }
3656                           else
3657                             {
3658                               if (((word >> 22) & 0x1) == 0)
3659                                 {
3660                                   /* 33222222222211111111110000000000
3661                                      10987654321098765432109876543210
3662                                      xxxxxxxxxx1xxxxxxxxxxx0x001111xx
3663                                      str.  */
3664                                   return 652;
3665                                 }
3666                               else
3667                                 {
3668                                   /* 33222222222211111111110000000000
3669                                      10987654321098765432109876543210
3670                                      xxxxxxxxxx1xxxxxxxxxxx1x001111xx
3671                                      ldr.  */
3672                                   return 653;
3673                                 }
3674                             }
3675                         }
3676                     }
3677                   else
3678                     {
3679                       if (((word >> 22) & 0x1) == 0)
3680                         {
3681                           /* 33222222222211111111110000000000
3682                              10987654321098765432109876543210
3683                              xxxxxxxxxxxxxxxxxxxxxx0x10111xxx
3684                              str.  */
3685                           return 663;
3686                         }
3687                       else
3688                         {
3689                           /* 33222222222211111111110000000000
3690                              10987654321098765432109876543210
3691                              xxxxxxxxxxxxxxxxxxxxxx1x10111xxx
3692                              ldr.  */
3693                           return 664;
3694                         }
3695                     }
3696                 }
3697             }
3698           else
3699             {
3700               if (((word >> 24) & 0x1) == 0)
3701                 {
3702                   if (((word >> 21) & 0x1) == 0)
3703                     {
3704                       if (((word >> 28) & 0x1) == 0)
3705                         {
3706                           if (((word >> 10) & 0x1) == 0)
3707                             {
3708                               if (((word >> 29) & 0x1) == 0)
3709                                 {
3710                                   if (((word >> 11) & 0x1) == 0)
3711                                     {
3712                                       if (((word >> 12) & 0x1) == 0)
3713                                         {
3714                                           /* 33222222222211111111110000000000
3715                                              10987654321098765432109876543210
3716                                              xxxxxxxxxx000xxxxxxxx0xx011100xx
3717                                              tbl.  */
3718                                           return 341;
3719                                         }
3720                                       else
3721                                         {
3722                                           /* 33222222222211111111110000000000
3723                                              10987654321098765432109876543210
3724                                              xxxxxxxxxx001xxxxxxxx0xx011100xx
3725                                              tbx.  */
3726                                           return 342;
3727                                         }
3728                                     }
3729                                   else
3730                                     {
3731                                       if (((word >> 12) & 0x1) == 0)
3732                                         {
3733                                           if (((word >> 14) & 0x1) == 0)
3734                                             {
3735                                               /* 33222222222211111111110000000000
3736                                                  10987654321098765432109876543210
3737                                                  xxxxxxxxxx010x0xxxxxx0xx011100xx
3738                                                  trn1.  */
3739                                               return 216;
3740                                             }
3741                                           else
3742                                             {
3743                                               /* 33222222222211111111110000000000
3744                                                  10987654321098765432109876543210
3745                                                  xxxxxxxxxx010x1xxxxxx0xx011100xx
3746                                                  trn2.  */
3747                                               return 219;
3748                                             }
3749                                         }
3750                                       else
3751                                         {
3752                                           if (((word >> 13) & 0x1) == 0)
3753                                             {
3754                                               if (((word >> 14) & 0x1) == 0)
3755                                                 {
3756                                                   /* 33222222222211111111110000000000
3757                                                      10987654321098765432109876543210
3758                                                      xxxxxxxxxx01100xxxxxx0xx011100xx
3759                                                      uzp1.  */
3760                                                   return 215;
3761                                                 }
3762                                               else
3763                                                 {
3764                                                   /* 33222222222211111111110000000000
3765                                                      10987654321098765432109876543210
3766                                                      xxxxxxxxxx01101xxxxxx0xx011100xx
3767                                                      uzp2.  */
3768                                                   return 218;
3769                                                 }
3770                                             }
3771                                           else
3772                                             {
3773                                               if (((word >> 14) & 0x1) == 0)
3774                                                 {
3775                                                   /* 33222222222211111111110000000000
3776                                                      10987654321098765432109876543210
3777                                                      xxxxxxxxxx01110xxxxxx0xx011100xx
3778                                                      zip1.  */
3779                                                   return 217;
3780                                                 }
3781                                               else
3782                                                 {
3783                                                   /* 33222222222211111111110000000000
3784                                                      10987654321098765432109876543210
3785                                                      xxxxxxxxxx01111xxxxxx0xx011100xx
3786                                                      zip2.  */
3787                                                   return 220;
3788                                                 }
3789                                             }
3790                                         }
3791                                     }
3792                                 }
3793                               else
3794                                 {
3795                                   /* 33222222222211111111110000000000
3796                                      10987654321098765432109876543210
3797                                      xxxxxxxxxx0xxxxxxxxxx0xx011101xx
3798                                      ext.  */
3799                                   return 119;
3800                                 }
3801                             }
3802                           else
3803                             {
3804                               if (((word >> 29) & 0x1) == 0)
3805                                 {
3806                                   if (((word >> 11) & 0x1) == 0)
3807                                     {
3808                                       /* 33222222222211111111110000000000
3809                                          10987654321098765432109876543210
3810                                          xxxxxxxxxx10xxxxxxxxx0xx011100xx
3811                                          dup.  */
3812                                       return 135;
3813                                     }
3814                                   else
3815                                     {
3816                                       if (((word >> 12) & 0x1) == 0)
3817                                         {
3818                                           if (((word >> 13) & 0x1) == 0)
3819                                             {
3820                                               /* 33222222222211111111110000000000
3821                                                  10987654321098765432109876543210
3822                                                  xxxxxxxxxx1100xxxxxxx0xx011100xx
3823                                                  dup.  */
3824                                               return 136;
3825                                             }
3826                                           else
3827                                             {
3828                                               /* 33222222222211111111110000000000
3829                                                  10987654321098765432109876543210
3830                                                  xxxxxxxxxx1101xxxxxxx0xx011100xx
3831                                                  smov.  */
3832                                               return 137;
3833                                             }
3834                                         }
3835                                       else
3836                                         {
3837                                           if (((word >> 13) & 0x1) == 0)
3838                                             {
3839                                               /* 33222222222211111111110000000000
3840                                                  10987654321098765432109876543210
3841                                                  xxxxxxxxxx1110xxxxxxx0xx011100xx
3842                                                  ins.  */
3843                                               return 140;
3844                                             }
3845                                           else
3846                                             {
3847                                               /* 33222222222211111111110000000000
3848                                                  10987654321098765432109876543210
3849                                                  xxxxxxxxxx1111xxxxxxx0xx011100xx
3850                                                  umov.  */
3851                                               return 138;
3852                                             }
3853                                         }
3854                                     }
3855                                 }
3856                               else
3857                                 {
3858                                   /* 33222222222211111111110000000000
3859                                      10987654321098765432109876543210
3860                                      xxxxxxxxxx1xxxxxxxxxx0xx011101xx
3861                                      ins.  */
3862                                   return 142;
3863                                 }
3864                             }
3865                         }
3866                       else
3867                         {
3868                           if (((word >> 30) & 0x1) == 0)
3869                             {
3870                               if (((word >> 16) & 0x1) == 0)
3871                                 {
3872                                   if (((word >> 17) & 0x1) == 0)
3873                                     {
3874                                       /* 33222222222211111111110000000000
3875                                          10987654321098765432109876543210
3876                                          xxxxxxxxxxxxxxxx00xxx0xx01111x0x
3877                                          fcvtzs.  */
3878                                       return 598;
3879                                     }
3880                                   else
3881                                     {
3882                                       /* 33222222222211111111110000000000
3883                                          10987654321098765432109876543210
3884                                          xxxxxxxxxxxxxxxx01xxx0xx01111x0x
3885                                          scvtf.  */
3886                                       return 596;
3887                                     }
3888                                 }
3889                               else
3890                                 {
3891                                   if (((word >> 17) & 0x1) == 0)
3892                                     {
3893                                       /* 33222222222211111111110000000000
3894                                          10987654321098765432109876543210
3895                                          xxxxxxxxxxxxxxxx10xxx0xx01111x0x
3896                                          fcvtzu.  */
3897                                       return 599;
3898                                     }
3899                                   else
3900                                     {
3901                                       /* 33222222222211111111110000000000
3902                                          10987654321098765432109876543210
3903                                          xxxxxxxxxxxxxxxx11xxx0xx01111x0x
3904                                          ucvtf.  */
3905                                       return 597;
3906                                     }
3907                                 }
3908                             }
3909                           else
3910                             {
3911                               if (((word >> 10) & 0x1) == 0)
3912                                 {
3913                                   if (((word >> 12) & 0x1) == 0)
3914                                     {
3915                                       if (((word >> 13) & 0x1) == 0)
3916                                         {
3917                                           if (((word >> 14) & 0x1) == 0)
3918                                             {
3919                                               /* 33222222222211111111110000000000
3920                                                  10987654321098765432109876543210
3921                                                  xxxxxxxxxx0x000xxxxxx0xx01111x1x
3922                                                  sha1c.  */
3923                                               return 540;
3924                                             }
3925                                           else
3926                                             {
3927                                               /* 33222222222211111111110000000000
3928                                                  10987654321098765432109876543210
3929                                                  xxxxxxxxxx0x001xxxxxx0xx01111x1x
3930                                                  sha256h.  */
3931                                               return 544;
3932                                             }
3933                                         }
3934                                       else
3935                                         {
3936                                           if (((word >> 14) & 0x1) == 0)
3937                                             {
3938                                               /* 33222222222211111111110000000000
3939                                                  10987654321098765432109876543210
3940                                                  xxxxxxxxxx0x010xxxxxx0xx01111x1x
3941                                                  sha1m.  */
3942                                               return 542;
3943                                             }
3944                                           else
3945                                             {
3946                                               /* 33222222222211111111110000000000
3947                                                  10987654321098765432109876543210
3948                                                  xxxxxxxxxx0x011xxxxxx0xx01111x1x
3949                                                  sha256su1.  */
3950                                               return 546;
3951                                             }
3952                                         }
3953                                     }
3954                                   else
3955                                     {
3956                                       if (((word >> 13) & 0x1) == 0)
3957                                         {
3958                                           if (((word >> 14) & 0x1) == 0)
3959                                             {
3960                                               /* 33222222222211111111110000000000
3961                                                  10987654321098765432109876543210
3962                                                  xxxxxxxxxx0x100xxxxxx0xx01111x1x
3963                                                  sha1p.  */
3964                                               return 541;
3965                                             }
3966                                           else
3967                                             {
3968                                               /* 33222222222211111111110000000000
3969                                                  10987654321098765432109876543210
3970                                                  xxxxxxxxxx0x101xxxxxx0xx01111x1x
3971                                                  sha256h2.  */
3972                                               return 545;
3973                                             }
3974                                         }
3975                                       else
3976                                         {
3977                                           /* 33222222222211111111110000000000
3978                                              10987654321098765432109876543210
3979                                              xxxxxxxxxx0x11xxxxxxx0xx01111x1x
3980                                              sha1su0.  */
3981                                           return 543;
3982                                         }
3983                                     }
3984                                 }
3985                               else
3986                                 {
3987                                   /* 33222222222211111111110000000000
3988                                      10987654321098765432109876543210
3989                                      xxxxxxxxxx1xxxxxxxxxx0xx01111x1x
3990                                      dup.  */
3991                                   return 430;
3992                                 }
3993                             }
3994                         }
3995                     }
3996                   else
3997                     {
3998                       if (((word >> 10) & 0x1) == 0)
3999                         {
4000                           if (((word >> 11) & 0x1) == 0)
4001                             {
4002                               if (((word >> 12) & 0x1) == 0)
4003                                 {
4004                                   if (((word >> 13) & 0x1) == 0)
4005                                     {
4006                                       if (((word >> 14) & 0x1) == 0)
4007                                         {
4008                                           if (((word >> 15) & 0x1) == 0)
4009                                             {
4010                                               if (((word >> 28) & 0x1) == 0)
4011                                                 {
4012                                                   if (((word >> 29) & 0x1) == 0)
4013                                                     {
4014                                                       if (((word >> 30) & 0x1) == 0)
4015                                                         {
4016                                                           /* 33222222222211111111110000000000
4017                                                              10987654321098765432109876543210
4018                                                              xxxxxxxxxx000000xxxxx1xx0111000x
4019                                                              saddl.  */
4020                                                           return 38;
4021                                                         }
4022                                                       else
4023                                                         {
4024                                                           /* 33222222222211111111110000000000
4025                                                              10987654321098765432109876543210
4026                                                              xxxxxxxxxx000000xxxxx1xx0111001x
4027                                                              saddl2.  */
4028                                                           return 39;
4029                                                         }
4030                                                     }
4031                                                   else
4032                                                     {
4033                                                       if (((word >> 30) & 0x1) == 0)
4034                                                         {
4035                                                           /* 33222222222211111111110000000000
4036                                                              10987654321098765432109876543210
4037                                                              xxxxxxxxxx000000xxxxx1xx0111010x
4038                                                              uaddl.  */
4039                                                           return 70;
4040                                                         }
4041                                                       else
4042                                                         {
4043                                                           /* 33222222222211111111110000000000
4044                                                              10987654321098765432109876543210
4045                                                              xxxxxxxxxx000000xxxxx1xx0111011x
4046                                                              uaddl2.  */
4047                                                           return 71;
4048                                                         }
4049                                                     }
4050                                                 }
4051                                               else
4052                                                 {
4053                                                   if (((word >> 16) & 0x1) == 0)
4054                                                     {
4055                                                       if (((word >> 17) & 0x1) == 0)
4056                                                         {
4057                                                           if (((word >> 18) & 0x1) == 0)
4058                                                             {
4059                                                               if (((word >> 19) & 0x1) == 0)
4060                                                                 {
4061                                                                   if (((word >> 20) & 0x1) == 0)
4062                                                                     {
4063                                                                       /* 33222222222211111111110000000000
4064                                                                          10987654321098765432109876543210
4065                                                                          xxxxxxxxxx000000000001xx01111xxx
4066                                                                          fcvtns.  */
4067                                                                       return 600;
4068                                                                     }
4069                                                                   else
4070                                                                     {
4071                                                                       /* 33222222222211111111110000000000
4072                                                                          10987654321098765432109876543210
4073                                                                          xxxxxxxxxx000000000011xx01111xxx
4074                                                                          fcvtms.  */
4075                                                                       return 610;
4076                                                                     }
4077                                                                 }
4078                                                               else
4079                                                                 {
4080                                                                   if (((word >> 20) & 0x1) == 0)
4081                                                                     {
4082                                                                       /* 33222222222211111111110000000000
4083                                                                          10987654321098765432109876543210
4084                                                                          xxxxxxxxxx000000000101xx01111xxx
4085                                                                          fcvtps.  */
4086                                                                       return 608;
4087                                                                     }
4088                                                                   else
4089                                                                     {
4090                                                                       /* 33222222222211111111110000000000
4091                                                                          10987654321098765432109876543210
4092                                                                          xxxxxxxxxx000000000111xx01111xxx
4093                                                                          fcvtzs.  */
4094                                                                       return 612;
4095                                                                     }
4096                                                                 }
4097                                                             }
4098                                                           else
4099                                                             {
4100                                                               /* 33222222222211111111110000000000
4101                                                                  10987654321098765432109876543210
4102                                                                  xxxxxxxxxx000000001xx1xx01111xxx
4103                                                                  fcvtas.  */
4104                                                               return 604;
4105                                                             }
4106                                                         }
4107                                                       else
4108                                                         {
4109                                                           if (((word >> 18) & 0x1) == 0)
4110                                                             {
4111                                                               /* 33222222222211111111110000000000
4112                                                                  10987654321098765432109876543210
4113                                                                  xxxxxxxxxx000000010xx1xx01111xxx
4114                                                                  scvtf.  */
4115                                                               return 602;
4116                                                             }
4117                                                           else
4118                                                             {
4119                                                               if (((word >> 19) & 0x1) == 0)
4120                                                                 {
4121                                                                   /* 33222222222211111111110000000000
4122                                                                      10987654321098765432109876543210
4123                                                                      xxxxxxxxxx0000000110x1xx01111xxx
4124                                                                      fmov.  */
4125                                                                   return 606;
4126                                                                 }
4127                                                               else
4128                                                                 {
4129                                                                   /* 33222222222211111111110000000000
4130                                                                      10987654321098765432109876543210
4131                                                                      xxxxxxxxxx0000000111x1xx01111xxx
4132                                                                      fmov.  */
4133                                                                   return 614;
4134                                                                 }
4135                                                             }
4136                                                         }
4137                                                     }
4138                                                   else
4139                                                     {
4140                                                       if (((word >> 17) & 0x1) == 0)
4141                                                         {
4142                                                           if (((word >> 18) & 0x1) == 0)
4143                                                             {
4144                                                               if (((word >> 19) & 0x1) == 0)
4145                                                                 {
4146                                                                   if (((word >> 20) & 0x1) == 0)
4147                                                                     {
4148                                                                       /* 33222222222211111111110000000000
4149                                                                          10987654321098765432109876543210
4150                                                                          xxxxxxxxxx000000100001xx01111xxx
4151                                                                          fcvtnu.  */
4152                                                                       return 601;
4153                                                                     }
4154                                                                   else
4155                                                                     {
4156                                                                       /* 33222222222211111111110000000000
4157                                                                          10987654321098765432109876543210
4158                                                                          xxxxxxxxxx000000100011xx01111xxx
4159                                                                          fcvtmu.  */
4160                                                                       return 611;
4161                                                                     }
4162                                                                 }
4163                                                               else
4164                                                                 {
4165                                                                   if (((word >> 20) & 0x1) == 0)
4166                                                                     {
4167                                                                       /* 33222222222211111111110000000000
4168                                                                          10987654321098765432109876543210
4169                                                                          xxxxxxxxxx000000100101xx01111xxx
4170                                                                          fcvtpu.  */
4171                                                                       return 609;
4172                                                                     }
4173                                                                   else
4174                                                                     {
4175                                                                       /* 33222222222211111111110000000000
4176                                                                          10987654321098765432109876543210
4177                                                                          xxxxxxxxxx000000100111xx01111xxx
4178                                                                          fcvtzu.  */
4179                                                                       return 613;
4180                                                                     }
4181                                                                 }
4182                                                             }
4183                                                           else
4184                                                             {
4185                                                               /* 33222222222211111111110000000000
4186                                                                  10987654321098765432109876543210
4187                                                                  xxxxxxxxxx000000101xx1xx01111xxx
4188                                                                  fcvtau.  */
4189                                                               return 605;
4190                                                             }
4191                                                         }
4192                                                       else
4193                                                         {
4194                                                           if (((word >> 18) & 0x1) == 0)
4195                                                             {
4196                                                               /* 33222222222211111111110000000000
4197                                                                  10987654321098765432109876543210
4198                                                                  xxxxxxxxxx000000110xx1xx01111xxx
4199                                                                  ucvtf.  */
4200                                                               return 603;
4201                                                             }
4202                                                           else
4203                                                             {
4204                                                               if (((word >> 19) & 0x1) == 0)
4205                                                                 {
4206                                                                   /* 33222222222211111111110000000000
4207                                                                      10987654321098765432109876543210
4208                                                                      xxxxxxxxxx0000001110x1xx01111xxx
4209                                                                      fmov.  */
4210                                                                   return 607;
4211                                                                 }
4212                                                               else
4213                                                                 {
4214                                                                   /* 33222222222211111111110000000000
4215                                                                      10987654321098765432109876543210
4216                                                                      xxxxxxxxxx0000001111x1xx01111xxx
4217                                                                      fmov.  */
4218                                                                   return 615;
4219                                                                 }
4220                                                             }
4221                                                         }
4222                                                     }
4223                                                 }
4224                                             }
4225                                           else
4226                                             {
4227                                               if (((word >> 29) & 0x1) == 0)
4228                                                 {
4229                                                   if (((word >> 30) & 0x1) == 0)
4230                                                     {
4231                                                       /* 33222222222211111111110000000000
4232                                                          10987654321098765432109876543210
4233                                                          xxxxxxxxxx000001xxxxx1xx0111x00x
4234                                                          smlal.  */
4235                                                       return 54;
4236                                                     }
4237                                                   else
4238                                                     {
4239                                                       /* 33222222222211111111110000000000
4240                                                          10987654321098765432109876543210
4241                                                          xxxxxxxxxx000001xxxxx1xx0111x01x
4242                                                          smlal2.  */
4243                                                       return 55;
4244                                                     }
4245                                                 }
4246                                               else
4247                                                 {
4248                                                   if (((word >> 30) & 0x1) == 0)
4249                                                     {
4250                                                       /* 33222222222211111111110000000000
4251                                                          10987654321098765432109876543210
4252                                                          xxxxxxxxxx000001xxxxx1xx0111x10x
4253                                                          umlal.  */
4254                                                       return 86;
4255                                                     }
4256                                                   else
4257                                                     {
4258                                                       /* 33222222222211111111110000000000
4259                                                          10987654321098765432109876543210
4260                                                          xxxxxxxxxx000001xxxxx1xx0111x11x
4261                                                          umlal2.  */
4262                                                       return 87;
4263                                                     }
4264                                                 }
4265                                             }
4266                                         }
4267                                       else
4268                                         {
4269                                           if (((word >> 28) & 0x1) == 0)
4270                                             {
4271                                               if (((word >> 15) & 0x1) == 0)
4272                                                 {
4273                                                   if (((word >> 29) & 0x1) == 0)
4274                                                     {
4275                                                       if (((word >> 30) & 0x1) == 0)
4276                                                         {
4277                                                           /* 33222222222211111111110000000000
4278                                                              10987654321098765432109876543210
4279                                                              xxxxxxxxxx000010xxxxx1xx0111000x
4280                                                              addhn.  */
4281                                                           return 46;
4282                                                         }
4283                                                       else
4284                                                         {
4285                                                           /* 33222222222211111111110000000000
4286                                                              10987654321098765432109876543210
4287                                                              xxxxxxxxxx000010xxxxx1xx0111001x
4288                                                              addhn2.  */
4289                                                           return 47;
4290                                                         }
4291                                                     }
4292                                                   else
4293                                                     {
4294                                                       if (((word >> 30) & 0x1) == 0)
4295                                                         {
4296                                                           /* 33222222222211111111110000000000
4297                                                              10987654321098765432109876543210
4298                                                              xxxxxxxxxx000010xxxxx1xx0111010x
4299                                                              raddhn.  */
4300                                                           return 78;
4301                                                         }
4302                                                       else
4303                                                         {
4304                                                           /* 33222222222211111111110000000000
4305                                                              10987654321098765432109876543210
4306                                                              xxxxxxxxxx000010xxxxx1xx0111011x
4307                                                              raddhn2.  */
4308                                                           return 79;
4309                                                         }
4310                                                     }
4311                                                 }
4312                                               else
4313                                                 {
4314                                                   if (((word >> 29) & 0x1) == 0)
4315                                                     {
4316                                                       if (((word >> 30) & 0x1) == 0)
4317                                                         {
4318                                                           /* 33222222222211111111110000000000
4319                                                              10987654321098765432109876543210
4320                                                              xxxxxxxxxx000011xxxxx1xx0111000x
4321                                                              smull.  */
4322                                                           return 62;
4323                                                         }
4324                                                       else
4325                                                         {
4326                                                           /* 33222222222211111111110000000000
4327                                                              10987654321098765432109876543210
4328                                                              xxxxxxxxxx000011xxxxx1xx0111001x
4329                                                              smull2.  */
4330                                                           return 63;
4331                                                         }
4332                                                     }
4333                                                   else
4334                                                     {
4335                                                       if (((word >> 30) & 0x1) == 0)
4336                                                         {
4337                                                           /* 33222222222211111111110000000000
4338                                                              10987654321098765432109876543210
4339                                                              xxxxxxxxxx000011xxxxx1xx0111010x
4340                                                              umull.  */
4341                                                           return 90;
4342                                                         }
4343                                                       else
4344                                                         {
4345                                                           /* 33222222222211111111110000000000
4346                                                              10987654321098765432109876543210
4347                                                              xxxxxxxxxx000011xxxxx1xx0111011x
4348                                                              umull2.  */
4349                                                           return 91;
4350                                                         }
4351                                                     }
4352                                                 }
4353                                             }
4354                                           else
4355                                             {
4356                                               if (((word >> 17) & 0x1) == 0)
4357                                                 {
4358                                                   if (((word >> 15) & 0x1) == 0)
4359                                                     {
4360                                                       if (((word >> 16) & 0x1) == 0)
4361                                                         {
4362                                                           if (((word >> 18) & 0x1) == 0)
4363                                                             {
4364                                                               /* 33222222222211111111110000000000
4365                                                                  10987654321098765432109876543210
4366                                                                  xxxxxxxxxx000010000xx1xx01111xxx
4367                                                                  fmov.  */
4368                                                               return 622;
4369                                                             }
4370                                                           else
4371                                                             {
4372                                                               /* 33222222222211111111110000000000
4373                                                                  10987654321098765432109876543210
4374                                                                  xxxxxxxxxx000010001xx1xx01111xxx
4375                                                                  frintn.  */
4376                                                               return 627;
4377                                                             }
4378                                                         }
4379                                                       else
4380                                                         {
4381                                                           if (((word >> 18) & 0x1) == 0)
4382                                                             {
4383                                                               /* 33222222222211111111110000000000
4384                                                                  10987654321098765432109876543210
4385                                                                  xxxxxxxxxx000010100xx1xx01111xxx
4386                                                                  fneg.  */
4387                                                               return 624;
4388                                                             }
4389                                                           else
4390                                                             {
4391                                                               /* 33222222222211111111110000000000
4392                                                                  10987654321098765432109876543210
4393                                                                  xxxxxxxxxx000010101xx1xx01111xxx
4394                                                                  frintm.  */
4395                                                               return 629;
4396                                                             }
4397                                                         }
4398                                                     }
4399                                                   else
4400                                                     {
4401                                                       if (((word >> 16) & 0x1) == 0)
4402                                                         {
4403                                                           if (((word >> 18) & 0x1) == 0)
4404                                                             {
4405                                                               /* 33222222222211111111110000000000
4406                                                                  10987654321098765432109876543210
4407                                                                  xxxxxxxxxx000011000xx1xx01111xxx
4408                                                                  fabs.  */
4409                                                               return 623;
4410                                                             }
4411                                                           else
4412                                                             {
4413                                                               /* 33222222222211111111110000000000
4414                                                                  10987654321098765432109876543210
4415                                                                  xxxxxxxxxx000011001xx1xx01111xxx
4416                                                                  frintp.  */
4417                                                               return 628;
4418                                                             }
4419                                                         }
4420                                                       else
4421                                                         {
4422                                                           if (((word >> 18) & 0x1) == 0)
4423                                                             {
4424                                                               /* 33222222222211111111110000000000
4425                                                                  10987654321098765432109876543210
4426                                                                  xxxxxxxxxx000011100xx1xx01111xxx
4427                                                                  fsqrt.  */
4428                                                               return 625;
4429                                                             }
4430                                                           else
4431                                                             {
4432                                                               /* 33222222222211111111110000000000
4433                                                                  10987654321098765432109876543210
4434                                                                  xxxxxxxxxx000011101xx1xx01111xxx
4435                                                                  frintz.  */
4436                                                               return 630;
4437                                                             }
4438                                                         }
4439                                                     }
4440                                                 }
4441                                               else
4442                                                 {
4443                                                   if (((word >> 18) & 0x1) == 0)
4444                                                     {
4445                                                       /* 33222222222211111111110000000000
4446                                                          10987654321098765432109876543210
4447                                                          xxxxxxxxxx00001xx10xx1xx01111xxx
4448                                                          fcvt.  */
4449                                                       return 626;
4450                                                     }
4451                                                   else
4452                                                     {
4453                                                       if (((word >> 15) & 0x1) == 0)
4454                                                         {
4455                                                           if (((word >> 16) & 0x1) == 0)
4456                                                             {
4457                                                               /* 33222222222211111111110000000000
4458                                                                  10987654321098765432109876543210
4459                                                                  xxxxxxxxxx000010011xx1xx01111xxx
4460                                                                  frinta.  */
4461                                                               return 631;
4462                                                             }
4463                                                           else
4464                                                             {
4465                                                               /* 33222222222211111111110000000000
4466                                                                  10987654321098765432109876543210
4467                                                                  xxxxxxxxxx000010111xx1xx01111xxx
4468                                                                  frintx.  */
4469                                                               return 632;
4470                                                             }
4471                                                         }
4472                                                       else
4473                                                         {
4474                                                           /* 33222222222211111111110000000000
4475                                                              10987654321098765432109876543210
4476                                                              xxxxxxxxxx000011x11xx1xx01111xxx
4477                                                              frinti.  */
4478                                                           return 633;
4479                                                         }
4480                                                     }
4481                                                 }
4482                                             }
4483                                         }
4484                                     }
4485                                   else
4486                                     {
4487                                       if (((word >> 14) & 0x1) == 0)
4488                                         {
4489                                           if (((word >> 15) & 0x1) == 0)
4490                                             {
4491                                               if (((word >> 28) & 0x1) == 0)
4492                                                 {
4493                                                   if (((word >> 29) & 0x1) == 0)
4494                                                     {
4495                                                       if (((word >> 30) & 0x1) == 0)
4496                                                         {
4497                                                           /* 33222222222211111111110000000000
4498                                                              10987654321098765432109876543210
4499                                                              xxxxxxxxxx000100xxxxx1xx0111000x
4500                                                              ssubl.  */
4501                                                           return 42;
4502                                                         }
4503                                                       else
4504                                                         {
4505                                                           /* 33222222222211111111110000000000
4506                                                              10987654321098765432109876543210
4507                                                              xxxxxxxxxx000100xxxxx1xx0111001x
4508                                                              ssubl2.  */
4509                                                           return 43;
4510                                                         }
4511                                                     }
4512                                                   else
4513                                                     {
4514                                                       if (((word >> 30) & 0x1) == 0)
4515                                                         {
4516                                                           /* 33222222222211111111110000000000
4517                                                              10987654321098765432109876543210
4518                                                              xxxxxxxxxx000100xxxxx1xx0111010x
4519                                                              usubl.  */
4520                                                           return 74;
4521                                                         }
4522                                                       else
4523                                                         {
4524                                                           /* 33222222222211111111110000000000
4525                                                              10987654321098765432109876543210
4526                                                              xxxxxxxxxx000100xxxxx1xx0111011x
4527                                                              usubl2.  */
4528                                                           return 75;
4529                                                         }
4530                                                     }
4531                                                 }
4532                                               else
4533                                                 {
4534                                                   if (((word >> 3) & 0x1) == 0)
4535                                                     {
4536                                                       if (((word >> 4) & 0x1) == 0)
4537                                                         {
4538                                                           /* 33222222222211111111110000000000
4539                                                              10987654321098765432109876543210
4540                                                              xxx00xxxxx000100xxxxx1xx01111xxx
4541                                                              fcmp.  */
4542                                                           return 618;
4543                                                         }
4544                                                       else
4545                                                         {
4546                                                           /* 33222222222211111111110000000000
4547                                                              10987654321098765432109876543210
4548                                                              xxx01xxxxx000100xxxxx1xx01111xxx
4549                                                              fcmpe.  */
4550                                                           return 619;
4551                                                         }
4552                                                     }
4553                                                   else
4554                                                     {
4555                                                       if (((word >> 4) & 0x1) == 0)
4556                                                         {
4557                                                           /* 33222222222211111111110000000000
4558                                                              10987654321098765432109876543210
4559                                                              xxx10xxxxx000100xxxxx1xx01111xxx
4560                                                              fcmp.  */
4561                                                           return 620;
4562                                                         }
4563                                                       else
4564                                                         {
4565                                                           /* 33222222222211111111110000000000
4566                                                              10987654321098765432109876543210
4567                                                              xxx11xxxxx000100xxxxx1xx01111xxx
4568                                                              fcmpe.  */
4569                                                           return 621;
4570                                                         }
4571                                                     }
4572                                                 }
4573                                             }
4574                                           else
4575                                             {
4576                                               if (((word >> 29) & 0x1) == 0)
4577                                                 {
4578                                                   if (((word >> 30) & 0x1) == 0)
4579                                                     {
4580                                                       /* 33222222222211111111110000000000
4581                                                          10987654321098765432109876543210
4582                                                          xxxxxxxxxx000101xxxxx1xx0111x00x
4583                                                          smlsl.  */
4584                                                       return 58;
4585                                                     }
4586                                                   else
4587                                                     {
4588                                                       /* 33222222222211111111110000000000
4589                                                          10987654321098765432109876543210
4590                                                          xxxxxxxxxx000101xxxxx1xx0111x01x
4591                                                          smlsl2.  */
4592                                                       return 59;
4593                                                     }
4594                                                 }
4595                                               else
4596                                                 {
4597                                                   if (((word >> 30) & 0x1) == 0)
4598                                                     {
4599                                                       /* 33222222222211111111110000000000
4600                                                          10987654321098765432109876543210
4601                                                          xxxxxxxxxx000101xxxxx1xx0111x10x
4602                                                          umlsl.  */
4603                                                       return 88;
4604                                                     }
4605                                                   else
4606                                                     {
4607                                                       /* 33222222222211111111110000000000
4608                                                          10987654321098765432109876543210
4609                                                          xxxxxxxxxx000101xxxxx1xx0111x11x
4610                                                          umlsl2.  */
4611                                                       return 89;
4612                                                     }
4613                                                 }
4614                                             }
4615                                         }
4616                                       else
4617                                         {
4618                                           if (((word >> 15) & 0x1) == 0)
4619                                             {
4620                                               if (((word >> 29) & 0x1) == 0)
4621                                                 {
4622                                                   if (((word >> 30) & 0x1) == 0)
4623                                                     {
4624                                                       /* 33222222222211111111110000000000
4625                                                          10987654321098765432109876543210
4626                                                          xxxxxxxxxx000110xxxxx1xx0111x00x
4627                                                          subhn.  */
4628                                                       return 50;
4629                                                     }
4630                                                   else
4631                                                     {
4632                                                       /* 33222222222211111111110000000000
4633                                                          10987654321098765432109876543210
4634                                                          xxxxxxxxxx000110xxxxx1xx0111x01x
4635                                                          subhn2.  */
4636                                                       return 51;
4637                                                     }
4638                                                 }
4639                                               else
4640                                                 {
4641                                                   if (((word >> 30) & 0x1) == 0)
4642                                                     {
4643                                                       /* 33222222222211111111110000000000
4644                                                          10987654321098765432109876543210
4645                                                          xxxxxxxxxx000110xxxxx1xx0111x10x
4646                                                          rsubhn.  */
4647                                                       return 82;
4648                                                     }
4649                                                   else
4650                                                     {
4651                                                       /* 33222222222211111111110000000000
4652                                                          10987654321098765432109876543210
4653                                                          xxxxxxxxxx000110xxxxx1xx0111x11x
4654                                                          rsubhn2.  */
4655                                                       return 83;
4656                                                     }
4657                                                 }
4658                                             }
4659                                           else
4660                                             {
4661                                               if (((word >> 22) & 0x1) == 0)
4662                                                 {
4663                                                   if (((word >> 30) & 0x1) == 0)
4664                                                     {
4665                                                       /* 33222222222211111111110000000000
4666                                                          10987654321098765432109876543210
4667                                                          xxxxxxxxxx000111xxxxx10x0111xx0x
4668                                                          pmull.  */
4669                                                       return 66;
4670                                                     }
4671                                                   else
4672                                                     {
4673                                                       /* 33222222222211111111110000000000
4674                                                          10987654321098765432109876543210
4675                                                          xxxxxxxxxx000111xxxxx10x0111xx1x
4676                                                          pmull2.  */
4677                                                       return 68;
4678                                                     }
4679                                                 }
4680                                               else
4681                                                 {
4682                                                   if (((word >> 30) & 0x1) == 0)
4683                                                     {
4684                                                       /* 33222222222211111111110000000000
4685                                                          10987654321098765432109876543210
4686                                                          xxxxxxxxxx000111xxxxx11x0111xx0x
4687                                                          pmull.  */
4688                                                       return 67;
4689                                                     }
4690                                                   else
4691                                                     {
4692                                                       /* 33222222222211111111110000000000
4693                                                          10987654321098765432109876543210
4694                                                          xxxxxxxxxx000111xxxxx11x0111xx1x
4695                                                          pmull2.  */
4696                                                       return 69;
4697                                                     }
4698                                                 }
4699                                             }
4700                                         }
4701                                     }
4702                                 }
4703                               else
4704                                 {
4705                                   if (((word >> 28) & 0x1) == 0)
4706                                     {
4707                                       if (((word >> 13) & 0x1) == 0)
4708                                         {
4709                                           if (((word >> 14) & 0x1) == 0)
4710                                             {
4711                                               if (((word >> 15) & 0x1) == 0)
4712                                                 {
4713                                                   if (((word >> 29) & 0x1) == 0)
4714                                                     {
4715                                                       if (((word >> 30) & 0x1) == 0)
4716                                                         {
4717                                                           /* 33222222222211111111110000000000
4718                                                              10987654321098765432109876543210
4719                                                              xxxxxxxxxx001000xxxxx1xx0111000x
4720                                                              saddw.  */
4721                                                           return 40;
4722                                                         }
4723                                                       else
4724                                                         {
4725                                                           /* 33222222222211111111110000000000
4726                                                              10987654321098765432109876543210
4727                                                              xxxxxxxxxx001000xxxxx1xx0111001x
4728                                                              saddw2.  */
4729                                                           return 41;
4730                                                         }
4731                                                     }
4732                                                   else
4733                                                     {
4734                                                       if (((word >> 30) & 0x1) == 0)
4735                                                         {
4736                                                           /* 33222222222211111111110000000000
4737                                                              10987654321098765432109876543210
4738                                                              xxxxxxxxxx001000xxxxx1xx0111010x
4739                                                              uaddw.  */
4740                                                           return 72;
4741                                                         }
4742                                                       else
4743                                                         {
4744                                                           /* 33222222222211111111110000000000
4745                                                              10987654321098765432109876543210
4746                                                              xxxxxxxxxx001000xxxxx1xx0111011x
4747                                                              uaddw2.  */
4748                                                           return 73;
4749                                                         }
4750                                                     }
4751                                                 }
4752                                               else
4753                                                 {
4754                                                   if (((word >> 30) & 0x1) == 0)
4755                                                     {
4756                                                       /* 33222222222211111111110000000000
4757                                                          10987654321098765432109876543210
4758                                                          xxxxxxxxxx001001xxxxx1xx01110x0x
4759                                                          sqdmlal.  */
4760                                                       return 56;
4761                                                     }
4762                                                   else
4763                                                     {
4764                                                       /* 33222222222211111111110000000000
4765                                                          10987654321098765432109876543210
4766                                                          xxxxxxxxxx001001xxxxx1xx01110x1x
4767                                                          sqdmlal2.  */
4768                                                       return 57;
4769                                                     }
4770                                                 }
4771                                             }
4772                                           else
4773                                             {
4774                                               if (((word >> 15) & 0x1) == 0)
4775                                                 {
4776                                                   if (((word >> 29) & 0x1) == 0)
4777                                                     {
4778                                                       if (((word >> 30) & 0x1) == 0)
4779                                                         {
4780                                                           /* 33222222222211111111110000000000
4781                                                              10987654321098765432109876543210
4782                                                              xxxxxxxxxx001010xxxxx1xx0111000x
4783                                                              sabal.  */
4784                                                           return 48;
4785                                                         }
4786                                                       else
4787                                                         {
4788                                                           /* 33222222222211111111110000000000
4789                                                              10987654321098765432109876543210
4790                                                              xxxxxxxxxx001010xxxxx1xx0111001x
4791                                                              sabal2.  */
4792                                                           return 49;
4793                                                         }
4794                                                     }
4795                                                   else
4796                                                     {
4797                                                       if (((word >> 30) & 0x1) == 0)
4798                                                         {
4799                                                           /* 33222222222211111111110000000000
4800                                                              10987654321098765432109876543210
4801                                                              xxxxxxxxxx001010xxxxx1xx0111010x
4802                                                              uabal.  */
4803                                                           return 80;
4804                                                         }
4805                                                       else
4806                                                         {
4807                                                           /* 33222222222211111111110000000000
4808                                                              10987654321098765432109876543210
4809                                                              xxxxxxxxxx001010xxxxx1xx0111011x
4810                                                              uabal2.  */
4811                                                           return 81;
4812                                                         }
4813                                                     }
4814                                                 }
4815                                               else
4816                                                 {
4817                                                   if (((word >> 30) & 0x1) == 0)
4818                                                     {
4819                                                       /* 33222222222211111111110000000000
4820                                                          10987654321098765432109876543210
4821                                                          xxxxxxxxxx001011xxxxx1xx01110x0x
4822                                                          sqdmull.  */
4823                                                       return 64;
4824                                                     }
4825                                                   else
4826                                                     {
4827                                                       /* 33222222222211111111110000000000
4828                                                          10987654321098765432109876543210
4829                                                          xxxxxxxxxx001011xxxxx1xx01110x1x
4830                                                          sqdmull2.  */
4831                                                       return 65;
4832                                                     }
4833                                                 }
4834                                             }
4835                                         }
4836                                       else
4837                                         {
4838                                           if (((word >> 14) & 0x1) == 0)
4839                                             {
4840                                               if (((word >> 15) & 0x1) == 0)
4841                                                 {
4842                                                   if (((word >> 29) & 0x1) == 0)
4843                                                     {
4844                                                       if (((word >> 30) & 0x1) == 0)
4845                                                         {
4846                                                           /* 33222222222211111111110000000000
4847                                                              10987654321098765432109876543210
4848                                                              xxxxxxxxxx001100xxxxx1xx0111000x
4849                                                              ssubw.  */
4850                                                           return 44;
4851                                                         }
4852                                                       else
4853                                                         {
4854                                                           /* 33222222222211111111110000000000
4855                                                              10987654321098765432109876543210
4856                                                              xxxxxxxxxx001100xxxxx1xx0111001x
4857                                                              ssubw2.  */
4858                                                           return 45;
4859                                                         }
4860                                                     }
4861                                                   else
4862                                                     {
4863                                                       if (((word >> 30) & 0x1) == 0)
4864                                                         {
4865                                                           /* 33222222222211111111110000000000
4866                                                              10987654321098765432109876543210
4867                                                              xxxxxxxxxx001100xxxxx1xx0111010x
4868                                                              usubw.  */
4869                                                           return 76;
4870                                                         }
4871                                                       else
4872                                                         {
4873                                                           /* 33222222222211111111110000000000
4874                                                              10987654321098765432109876543210
4875                                                              xxxxxxxxxx001100xxxxx1xx0111011x
4876                                                              usubw2.  */
4877                                                           return 77;
4878                                                         }
4879                                                     }
4880                                                 }
4881                                               else
4882                                                 {
4883                                                   if (((word >> 30) & 0x1) == 0)
4884                                                     {
4885                                                       /* 33222222222211111111110000000000
4886                                                          10987654321098765432109876543210
4887                                                          xxxxxxxxxx001101xxxxx1xx01110x0x
4888                                                          sqdmlsl.  */
4889                                                       return 60;
4890                                                     }
4891                                                   else
4892                                                     {
4893                                                       /* 33222222222211111111110000000000
4894                                                          10987654321098765432109876543210
4895                                                          xxxxxxxxxx001101xxxxx1xx01110x1x
4896                                                          sqdmlsl2.  */
4897                                                       return 61;
4898                                                     }
4899                                                 }
4900                                             }
4901                                           else
4902                                             {
4903                                               if (((word >> 29) & 0x1) == 0)
4904                                                 {
4905                                                   if (((word >> 30) & 0x1) == 0)
4906                                                     {
4907                                                       /* 33222222222211111111110000000000
4908                                                          10987654321098765432109876543210
4909                                                          xxxxxxxxxx00111xxxxxx1xx0111000x
4910                                                          sabdl.  */
4911                                                       return 52;
4912                                                     }
4913                                                   else
4914                                                     {
4915                                                       /* 33222222222211111111110000000000
4916                                                          10987654321098765432109876543210
4917                                                          xxxxxxxxxx00111xxxxxx1xx0111001x
4918                                                          sabdl2.  */
4919                                                       return 53;
4920                                                     }
4921                                                 }
4922                                               else
4923                                                 {
4924                                                   if (((word >> 30) & 0x1) == 0)
4925                                                     {
4926                                                       /* 33222222222211111111110000000000
4927                                                          10987654321098765432109876543210
4928                                                          xxxxxxxxxx00111xxxxxx1xx0111010x
4929                                                          uabdl.  */
4930                                                       return 84;
4931                                                     }
4932                                                   else
4933                                                     {
4934                                                       /* 33222222222211111111110000000000
4935                                                          10987654321098765432109876543210
4936                                                          xxxxxxxxxx00111xxxxxx1xx0111011x
4937                                                          uabdl2.  */
4938                                                       return 85;
4939                                                     }
4940                                                 }
4941                                             }
4942                                         }
4943                                     }
4944                                   else
4945                                     {
4946                                       if (((word >> 30) & 0x1) == 0)
4947                                         {
4948                                           /* 33222222222211111111110000000000
4949                                              10987654321098765432109876543210
4950                                              xxxxxxxxxx001xxxxxxxx1xx01111x0x
4951                                              fmov.  */
4952                                           return 647;
4953                                         }
4954                                       else
4955                                         {
4956                                           if (((word >> 13) & 0x1) == 0)
4957                                             {
4958                                               if (((word >> 14) & 0x1) == 0)
4959                                                 {
4960                                                   /* 33222222222211111111110000000000
4961                                                      10987654321098765432109876543210
4962                                                      xxxxxxxxxx00100xxxxxx1xx01111x1x
4963                                                      sqdmlal.  */
4964                                                   return 343;
4965                                                 }
4966                                               else
4967                                                 {
4968                                                   /* 33222222222211111111110000000000
4969                                                      10987654321098765432109876543210
4970                                                      xxxxxxxxxx00101xxxxxx1xx01111x1x
4971                                                      sqdmull.  */
4972                                                   return 345;
4973                                                 }
4974                                             }
4975                                           else
4976                                             {
4977                                               /* 33222222222211111111110000000000
4978                                                  10987654321098765432109876543210
4979                                                  xxxxxxxxxx0011xxxxxxx1xx01111x1x
4980                                                  sqdmlsl.  */
4981                                               return 344;
4982                                             }
4983                                         }
4984                                     }
4985                                 }
4986                             }
4987                           else
4988                             {
4989                               if (((word >> 12) & 0x1) == 0)
4990                                 {
4991                                   if (((word >> 13) & 0x1) == 0)
4992                                     {
4993                                       if (((word >> 14) & 0x1) == 0)
4994                                         {
4995                                           if (((word >> 15) & 0x1) == 0)
4996                                             {
4997                                               if (((word >> 28) & 0x1) == 0)
4998                                                 {
4999                                                   if (((word >> 29) & 0x1) == 0)
5000                                                     {
5001                                                       /* 33222222222211111111110000000000
5002                                                          10987654321098765432109876543210
5003                                                          xxxxxxxxxx010000xxxxx1xx011100xx
5004                                                          rev64.  */
5005                                                       return 144;
5006                                                     }
5007                                                   else
5008                                                     {
5009                                                       /* 33222222222211111111110000000000
5010                                                          10987654321098765432109876543210
5011                                                          xxxxxxxxxx010000xxxxx1xx011101xx
5012                                                          rev32.  */
5013                                                       return 180;
5014                                                     }
5015                                                 }
5016                                               else
5017                                                 {
5018                                                   if (((word >> 30) & 0x1) == 0)
5019                                                     {
5020                                                       /* 33222222222211111111110000000000
5021                                                          10987654321098765432109876543210
5022                                                          xxxxxxxxxx010000xxxxx1xx01111x0x
5023                                                          fmul.  */
5024                                                       return 634;
5025                                                     }
5026                                                   else
5027                                                     {
5028                                                       /* 33222222222211111111110000000000
5029                                                          10987654321098765432109876543210
5030                                                          xxxxxxxxxx010000xxxxx1xx01111x1x
5031                                                          sha1h.  */
5032                                                       return 537;
5033                                                     }
5034                                                 }
5035                                             }
5036                                           else
5037                                             {
5038                                               if (((word >> 28) & 0x1) == 0)
5039                                                 {
5040                                                   if (((word >> 16) & 0x1) == 0)
5041                                                     {
5042                                                       if (((word >> 29) & 0x1) == 0)
5043                                                         {
5044                                                           /* 33222222222211111111110000000000
5045                                                              10987654321098765432109876543210
5046                                                              xxxxxxxxxx0100010xxxx1xx011100xx
5047                                                              cmgt.  */
5048                                                           return 152;
5049                                                         }
5050                                                       else
5051                                                         {
5052                                                           /* 33222222222211111111110000000000
5053                                                              10987654321098765432109876543210
5054                                                              xxxxxxxxxx0100010xxxx1xx011101xx
5055                                                              cmge.  */
5056                                                           return 186;
5057                                                         }
5058                                                     }
5059                                                   else
5060                                                     {
5061                                                       if (((word >> 23) & 0x1) == 0)
5062                                                         {
5063                                                           if (((word >> 29) & 0x1) == 0)
5064                                                             {
5065                                                               /* 33222222222211111111110000000000
5066                                                                  10987654321098765432109876543210
5067                                                                  xxxxxxxxxx0100011xxxx1x0011100xx
5068                                                                  frintn.  */
5069                                                               return 164;
5070                                                             }
5071                                                           else
5072                                                             {
5073                                                               /* 33222222222211111111110000000000
5074                                                                  10987654321098765432109876543210
5075                                                                  xxxxxxxxxx0100011xxxx1x0011101xx
5076                                                                  frinta.  */
5077                                                               return 197;
5078                                                             }
5079                                                         }
5080                                                       else
5081                                                         {
5082                                                           /* 33222222222211111111110000000000
5083                                                              10987654321098765432109876543210
5084                                                              xxxxxxxxxx0100011xxxx1x101110xxx
5085                                                              frintp.  */
5086                                                           return 174;
5087                                                         }
5088                                                     }
5089                                                 }
5090                                               else
5091                                                 {
5092                                                   if (((word >> 29) & 0x1) == 0)
5093                                                     {
5094                                                       if (((word >> 30) & 0x1) == 0)
5095                                                         {
5096                                                           /* 33222222222211111111110000000000
5097                                                              10987654321098765432109876543210
5098                                                              xxxxxxxxxx010001xxxxx1xx0111100x
5099                                                              fnmul.  */
5100                                                           return 642;
5101                                                         }
5102                                                       else
5103                                                         {
5104                                                           /* 33222222222211111111110000000000
5105                                                              10987654321098765432109876543210
5106                                                              xxxxxxxxxx010001xxxxx1xx0111101x
5107                                                              cmgt.  */
5108                                                           return 397;
5109                                                         }
5110                                                     }
5111                                                   else
5112                                                     {
5113                                                       /* 33222222222211111111110000000000
5114                                                          10987654321098765432109876543210
5115                                                          xxxxxxxxxx010001xxxxx1xx011111xx
5116                                                          cmge.  */
5117                                                       return 415;
5118                                                     }
5119                                                 }
5120                                             }
5121                                         }
5122                                       else
5123                                         {
5124                                           if (((word >> 15) & 0x1) == 0)
5125                                             {
5126                                               if (((word >> 28) & 0x1) == 0)
5127                                                 {
5128                                                   if (((word >> 16) & 0x1) == 0)
5129                                                     {
5130                                                       if (((word >> 19) & 0x1) == 0)
5131                                                         {
5132                                                           if (((word >> 29) & 0x1) == 0)
5133                                                             {
5134                                                               /* 33222222222211111111110000000000
5135                                                                  10987654321098765432109876543210
5136                                                                  xxxxxxxxxx0100100xx0x1xx011100xx
5137                                                                  cls.  */
5138                                                               return 148;
5139                                                             }
5140                                                           else
5141                                                             {
5142                                                               /* 33222222222211111111110000000000
5143                                                                  10987654321098765432109876543210
5144                                                                  xxxxxxxxxx0100100xx0x1xx011101xx
5145                                                                  clz.  */
5146                                                               return 183;
5147                                                             }
5148                                                         }
5149                                                       else
5150                                                         {
5151                                                           /* 33222222222211111111110000000000
5152                                                              10987654321098765432109876543210
5153                                                              xxxxxxxxxx0100100xx1x1xx01110xxx
5154                                                              aese.  */
5155                                                           return 533;
5156                                                         }
5157                                                     }
5158                                                   else
5159                                                     {
5160                                                       if (((word >> 29) & 0x1) == 0)
5161                                                         {
5162                                                           if (((word >> 30) & 0x1) == 0)
5163                                                             {
5164                                                               /* 33222222222211111111110000000000
5165                                                                  10987654321098765432109876543210
5166                                                                  xxxxxxxxxx0100101xxxx1xx0111000x
5167                                                                  sqxtn.  */
5168                                                               return 158;
5169                                                             }
5170                                                           else
5171                                                             {
5172                                                               /* 33222222222211111111110000000000
5173                                                                  10987654321098765432109876543210
5174                                                                  xxxxxxxxxx0100101xxxx1xx0111001x
5175                                                                  sqxtn2.  */
5176                                                               return 159;
5177                                                             }
5178                                                         }
5179                                                       else
5180                                                         {
5181                                                           if (((word >> 30) & 0x1) == 0)
5182                                                             {
5183                                                               /* 33222222222211111111110000000000
5184                                                                  10987654321098765432109876543210
5185                                                                  xxxxxxxxxx0100101xxxx1xx0111010x
5186                                                                  uqxtn.  */
5187                                                               return 193;
5188                                                             }
5189                                                           else
5190                                                             {
5191                                                               /* 33222222222211111111110000000000
5192                                                                  10987654321098765432109876543210
5193                                                                  xxxxxxxxxx0100101xxxx1xx0111011x
5194                                                                  uqxtn2.  */
5195                                                               return 194;
5196                                                             }
5197                                                         }
5198                                                     }
5199                                                 }
5200                                               else
5201                                                 {
5202                                                   if (((word >> 29) & 0x1) == 0)
5203                                                     {
5204                                                       if (((word >> 30) & 0x1) == 0)
5205                                                         {
5206                                                           /* 33222222222211111111110000000000
5207                                                              10987654321098765432109876543210
5208                                                              xxxxxxxxxx010010xxxxx1xx0111100x
5209                                                              fmax.  */
5210                                                           return 638;
5211                                                         }
5212                                                       else
5213                                                         {
5214                                                           /* 33222222222211111111110000000000
5215                                                              10987654321098765432109876543210
5216                                                              xxxxxxxxxx010010xxxxx1xx0111101x
5217                                                              sqxtn.  */
5218                                                           return 401;
5219                                                         }
5220                                                     }
5221                                                   else
5222                                                     {
5223                                                       /* 33222222222211111111110000000000
5224                                                          10987654321098765432109876543210
5225                                                          xxxxxxxxxx010010xxxxx1xx011111xx
5226                                                          uqxtn.  */
5227                                                       return 419;
5228                                                     }
5229                                                 }
5230                                             }
5231                                           else
5232                                             {
5233                                               if (((word >> 16) & 0x1) == 0)
5234                                                 {
5235                                                   if (((word >> 20) & 0x1) == 0)
5236                                                     {
5237                                                       if (((word >> 28) & 0x1) == 0)
5238                                                         {
5239                                                           if (((word >> 29) & 0x1) == 0)
5240                                                             {
5241                                                               /* 33222222222211111111110000000000
5242                                                                  10987654321098765432109876543210
5243                                                                  xxxxxxxxxx0100110xxx01xx011100xx
5244                                                                  fcmgt.  */
5245                                                               return 170;
5246                                                             }
5247                                                           else
5248                                                             {
5249                                                               /* 33222222222211111111110000000000
5250                                                                  10987654321098765432109876543210
5251                                                                  xxxxxxxxxx0100110xxx01xx011101xx
5252                                                                  fcmge.  */
5253                                                               return 206;
5254                                                             }
5255                                                         }
5256                                                       else
5257                                                         {
5258                                                           if (((word >> 29) & 0x1) == 0)
5259                                                             {
5260                                                               /* 33222222222211111111110000000000
5261                                                                  10987654321098765432109876543210
5262                                                                  xxxxxxxxxx0100110xxx01xx011110xx
5263                                                                  fcmgt.  */
5264                                                               return 406;
5265                                                             }
5266                                                           else
5267                                                             {
5268                                                               /* 33222222222211111111110000000000
5269                                                                  10987654321098765432109876543210
5270                                                                  xxxxxxxxxx0100110xxx01xx011111xx
5271                                                                  fcmge.  */
5272                                                               return 425;
5273                                                             }
5274                                                         }
5275                                                     }
5276                                                   else
5277                                                     {
5278                                                       if (((word >> 23) & 0x1) == 0)
5279                                                         {
5280                                                           if (((word >> 28) & 0x1) == 0)
5281                                                             {
5282                                                               /* 33222222222211111111110000000000
5283                                                                  10987654321098765432109876543210
5284                                                                  xxxxxxxxxx0100110xxx11x001110xxx
5285                                                                  fmaxnmv.  */
5286                                                               return 34;
5287                                                             }
5288                                                           else
5289                                                             {
5290                                                               /* 33222222222211111111110000000000
5291                                                                  10987654321098765432109876543210
5292                                                                  xxxxxxxxxx0100110xxx11x001111xxx
5293                                                                  fmaxnmp.  */
5294                                                               return 433;
5295                                                             }
5296                                                         }
5297                                                       else
5298                                                         {
5299                                                           if (((word >> 28) & 0x1) == 0)
5300                                                             {
5301                                                               /* 33222222222211111111110000000000
5302                                                                  10987654321098765432109876543210
5303                                                                  xxxxxxxxxx0100110xxx11x101110xxx
5304                                                                  fminnmv.  */
5305                                                               return 36;
5306                                                             }
5307                                                           else
5308                                                             {
5309                                                               /* 33222222222211111111110000000000
5310                                                                  10987654321098765432109876543210
5311                                                                  xxxxxxxxxx0100110xxx11x101111xxx
5312                                                                  fminnmp.  */
5313                                                               return 436;
5314                                                             }
5315                                                         }
5316                                                     }
5317                                                 }
5318                                               else
5319                                                 {
5320                                                   if (((word >> 23) & 0x1) == 0)
5321                                                     {
5322                                                       if (((word >> 28) & 0x1) == 0)
5323                                                         {
5324                                                           if (((word >> 29) & 0x1) == 0)
5325                                                             {
5326                                                               /* 33222222222211111111110000000000
5327                                                                  10987654321098765432109876543210
5328                                                                  xxxxxxxxxx0100111xxxx1x0011100xx
5329                                                                  fcvtas.  */
5330                                                               return 168;
5331                                                             }
5332                                                           else
5333                                                             {
5334                                                               /* 33222222222211111111110000000000
5335                                                                  10987654321098765432109876543210
5336                                                                  xxxxxxxxxx0100111xxxx1x0011101xx
5337                                                                  fcvtau.  */
5338                                                               return 201;
5339                                                             }
5340                                                         }
5341                                                       else
5342                                                         {
5343                                                           if (((word >> 29) & 0x1) == 0)
5344                                                             {
5345                                                               /* 33222222222211111111110000000000
5346                                                                  10987654321098765432109876543210
5347                                                                  xxxxxxxxxx0100111xxxx1x0011110xx
5348                                                                  fcvtas.  */
5349                                                               return 404;
5350                                                             }
5351                                                           else
5352                                                             {
5353                                                               /* 33222222222211111111110000000000
5354                                                                  10987654321098765432109876543210
5355                                                                  xxxxxxxxxx0100111xxxx1x0011111xx
5356                                                                  fcvtau.  */
5357                                                               return 423;
5358                                                             }
5359                                                         }
5360                                                     }
5361                                                   else
5362                                                     {
5363                                                       if (((word >> 29) & 0x1) == 0)
5364                                                         {
5365                                                           /* 33222222222211111111110000000000
5366                                                              10987654321098765432109876543210
5367                                                              xxxxxxxxxx0100111xxxx1x10111x0xx
5368                                                              urecpe.  */
5369                                                           return 178;
5370                                                         }
5371                                                       else
5372                                                         {
5373                                                           /* 33222222222211111111110000000000
5374                                                              10987654321098765432109876543210
5375                                                              xxxxxxxxxx0100111xxxx1x10111x1xx
5376                                                              ursqrte.  */
5377                                                           return 212;
5378                                                         }
5379                                                     }
5380                                                 }
5381                                             }
5382                                         }
5383                                     }
5384                                   else
5385                                     {
5386                                       if (((word >> 14) & 0x1) == 0)
5387                                         {
5388                                           if (((word >> 15) & 0x1) == 0)
5389                                             {
5390                                               if (((word >> 28) & 0x1) == 0)
5391                                                 {
5392                                                   if (((word >> 16) & 0x1) == 0)
5393                                                     {
5394                                                       if (((word >> 29) & 0x1) == 0)
5395                                                         {
5396                                                           /* 33222222222211111111110000000000
5397                                                              10987654321098765432109876543210
5398                                                              xxxxxxxxxx0101000xxxx1xx011100xx
5399                                                              saddlp.  */
5400                                                           return 146;
5401                                                         }
5402                                                       else
5403                                                         {
5404                                                           /* 33222222222211111111110000000000
5405                                                              10987654321098765432109876543210
5406                                                              xxxxxxxxxx0101000xxxx1xx011101xx
5407                                                              uaddlp.  */
5408                                                           return 181;
5409                                                         }
5410                                                     }
5411                                                   else
5412                                                     {
5413                                                       if (((word >> 29) & 0x1) == 0)
5414                                                         {
5415                                                           if (((word >> 30) & 0x1) == 0)
5416                                                             {
5417                                                               /* 33222222222211111111110000000000
5418                                                                  10987654321098765432109876543210
5419                                                                  xxxxxxxxxx0101001xxxx1xx0111000x
5420                                                                  xtn.  */
5421                                                               return 156;
5422                                                             }
5423                                                           else
5424                                                             {
5425                                                               /* 33222222222211111111110000000000
5426                                                                  10987654321098765432109876543210
5427                                                                  xxxxxxxxxx0101001xxxx1xx0111001x
5428                                                                  xtn2.  */
5429                                                               return 157;
5430                                                             }
5431                                                         }
5432                                                       else
5433                                                         {
5434                                                           if (((word >> 30) & 0x1) == 0)
5435                                                             {
5436                                                               /* 33222222222211111111110000000000
5437                                                                  10987654321098765432109876543210
5438                                                                  xxxxxxxxxx0101001xxxx1xx0111010x
5439                                                                  sqxtun.  */
5440                                                               return 189;
5441                                                             }
5442                                                           else
5443                                                             {
5444                                                               /* 33222222222211111111110000000000
5445                                                                  10987654321098765432109876543210
5446                                                                  xxxxxxxxxx0101001xxxx1xx0111011x
5447                                                                  sqxtun2.  */
5448                                                               return 190;
5449                                                             }
5450                                                         }
5451                                                     }
5452                                                 }
5453                                               else
5454                                                 {
5455                                                   if (((word >> 29) & 0x1) == 0)
5456                                                     {
5457                                                       if (((word >> 30) & 0x1) == 0)
5458                                                         {
5459                                                           /* 33222222222211111111110000000000
5460                                                              10987654321098765432109876543210
5461                                                              xxxxxxxxxx010100xxxxx1xx0111100x
5462                                                              fadd.  */
5463                                                           return 636;
5464                                                         }
5465                                                       else
5466                                                         {
5467                                                           /* 33222222222211111111110000000000
5468                                                              10987654321098765432109876543210
5469                                                              xxxxxxxxxx010100xxxxx1xx0111101x
5470                                                              sha256su0.  */
5471                                                           return 539;
5472                                                         }
5473                                                     }
5474                                                   else
5475                                                     {
5476                                                       /* 33222222222211111111110000000000
5477                                                          10987654321098765432109876543210
5478                                                          xxxxxxxxxx010100xxxxx1xx011111xx
5479                                                          sqxtun.  */
5480                                                       return 418;
5481                                                     }
5482                                                 }
5483                                             }
5484                                           else
5485                                             {
5486                                               if (((word >> 16) & 0x1) == 0)
5487                                                 {
5488                                                   if (((word >> 20) & 0x1) == 0)
5489                                                     {
5490                                                       if (((word >> 28) & 0x1) == 0)
5491                                                         {
5492                                                           /* 33222222222211111111110000000000
5493                                                              10987654321098765432109876543210
5494                                                              xxxxxxxxxx0101010xxx01xx01110xxx
5495                                                              cmlt.  */
5496                                                           return 154;
5497                                                         }
5498                                                       else
5499                                                         {
5500                                                           /* 33222222222211111111110000000000
5501                                                              10987654321098765432109876543210
5502                                                              xxxxxxxxxx0101010xxx01xx01111xxx
5503                                                              cmlt.  */
5504                                                           return 399;
5505                                                         }
5506                                                     }
5507                                                   else
5508                                                     {
5509                                                       if (((word >> 29) & 0x1) == 0)
5510                                                         {
5511                                                           /* 33222222222211111111110000000000
5512                                                              10987654321098765432109876543210
5513                                                              xxxxxxxxxx0101010xxx11xx0111x0xx
5514                                                              smaxv.  */
5515                                                           return 28;
5516                                                         }
5517                                                       else
5518                                                         {
5519                                                           /* 33222222222211111111110000000000
5520                                                              10987654321098765432109876543210
5521                                                              xxxxxxxxxx0101010xxx11xx0111x1xx
5522                                                              umaxv.  */
5523                                                           return 32;
5524                                                         }
5525                                                     }
5526                                                 }
5527                                               else
5528                                                 {
5529                                                   if (((word >> 20) & 0x1) == 0)
5530                                                     {
5531                                                       if (((word >> 23) & 0x1) == 0)
5532                                                         {
5533                                                           if (((word >> 28) & 0x1) == 0)
5534                                                             {
5535                                                               if (((word >> 29) & 0x1) == 0)
5536                                                                 {
5537                                                                   /* 33222222222211111111110000000000
5538                                                                      10987654321098765432109876543210
5539                                                                      xxxxxxxxxx0101011xxx01x0011100xx
5540                                                                      fcvtns.  */
5541                                                                   return 166;
5542                                                                 }
5543                                                               else
5544                                                                 {
5545                                                                   /* 33222222222211111111110000000000
5546                                                                      10987654321098765432109876543210
5547                                                                      xxxxxxxxxx0101011xxx01x0011101xx
5548                                                                      fcvtnu.  */
5549                                                                   return 199;
5550                                                                 }
5551                                                             }
5552                                                           else
5553                                                             {
5554                                                               if (((word >> 29) & 0x1) == 0)
5555                                                                 {
5556                                                                   /* 33222222222211111111110000000000
5557                                                                      10987654321098765432109876543210
5558                                                                      xxxxxxxxxx0101011xxx01x0011110xx
5559                                                                      fcvtns.  */
5560                                                                   return 402;
5561                                                                 }
5562                                                               else
5563                                                                 {
5564                                                                   /* 33222222222211111111110000000000
5565                                                                      10987654321098765432109876543210
5566                                                                      xxxxxxxxxx0101011xxx01x0011111xx
5567                                                                      fcvtnu.  */
5568                                                                   return 421;
5569                                                                 }
5570                                                             }
5571                                                         }
5572                                                       else
5573                                                         {
5574                                                           if (((word >> 28) & 0x1) == 0)
5575                                                             {
5576                                                               if (((word >> 29) & 0x1) == 0)
5577                                                                 {
5578                                                                   /* 33222222222211111111110000000000
5579                                                                      10987654321098765432109876543210
5580                                                                      xxxxxxxxxx0101011xxx01x1011100xx
5581                                                                      fcvtps.  */
5582                                                                   return 176;
5583                                                                 }
5584                                                               else
5585                                                                 {
5586                                                                   /* 33222222222211111111110000000000
5587                                                                      10987654321098765432109876543210
5588                                                                      xxxxxxxxxx0101011xxx01x1011101xx
5589                                                                      fcvtpu.  */
5590                                                                   return 210;
5591                                                                 }
5592                                                             }
5593                                                           else
5594                                                             {
5595                                                               if (((word >> 29) & 0x1) == 0)
5596                                                                 {
5597                                                                   /* 33222222222211111111110000000000
5598                                                                      10987654321098765432109876543210
5599                                                                      xxxxxxxxxx0101011xxx01x1011110xx
5600                                                                      fcvtps.  */
5601                                                                   return 409;
5602                                                                 }
5603                                                               else
5604                                                                 {
5605                                                                   /* 33222222222211111111110000000000
5606                                                                      10987654321098765432109876543210
5607                                                                      xxxxxxxxxx0101011xxx01x1011111xx
5608                                                                      fcvtpu.  */
5609                                                                   return 427;
5610                                                                 }
5611                                                             }
5612                                                         }
5613                                                     }
5614                                                   else
5615                                                     {
5616                                                       if (((word >> 29) & 0x1) == 0)
5617                                                         {
5618                                                           /* 33222222222211111111110000000000
5619                                                              10987654321098765432109876543210
5620                                                              xxxxxxxxxx0101011xxx11xx0111x0xx
5621                                                              sminv.  */
5622                                                           return 29;
5623                                                         }
5624                                                       else
5625                                                         {
5626                                                           /* 33222222222211111111110000000000
5627                                                              10987654321098765432109876543210
5628                                                              xxxxxxxxxx0101011xxx11xx0111x1xx
5629                                                              uminv.  */
5630                                                           return 33;
5631                                                         }
5632                                                     }
5633                                                 }
5634                                             }
5635                                         }
5636                                       else
5637                                         {
5638                                           if (((word >> 15) & 0x1) == 0)
5639                                             {
5640                                               if (((word >> 28) & 0x1) == 0)
5641                                                 {
5642                                                   if (((word >> 16) & 0x1) == 0)
5643                                                     {
5644                                                       if (((word >> 19) & 0x1) == 0)
5645                                                         {
5646                                                           if (((word >> 29) & 0x1) == 0)
5647                                                             {
5648                                                               /* 33222222222211111111110000000000
5649                                                                  10987654321098765432109876543210
5650                                                                  xxxxxxxxxx0101100xx0x1xx011100xx
5651                                                                  sadalp.  */
5652                                                               return 150;
5653                                                             }
5654                                                           else
5655                                                             {
5656                                                               /* 33222222222211111111110000000000
5657                                                                  10987654321098765432109876543210
5658                                                                  xxxxxxxxxx0101100xx0x1xx011101xx
5659                                                                  uadalp.  */
5660                                                               return 184;
5661                                                             }
5662                                                         }
5663                                                       else
5664                                                         {
5665                                                           /* 33222222222211111111110000000000
5666                                                              10987654321098765432109876543210
5667                                                              xxxxxxxxxx0101100xx1x1xx01110xxx
5668                                                              aesmc.  */
5669                                                           return 535;
5670                                                         }
5671                                                     }
5672                                                   else
5673                                                     {
5674                                                       if (((word >> 29) & 0x1) == 0)
5675                                                         {
5676                                                           if (((word >> 30) & 0x1) == 0)
5677                                                             {
5678                                                               /* 33222222222211111111110000000000
5679                                                                  10987654321098765432109876543210
5680                                                                  xxxxxxxxxx0101101xxxx1xx0111000x
5681                                                                  fcvtn.  */
5682                                                               return 160;
5683                                                             }
5684                                                           else
5685                                                             {
5686                                                               /* 33222222222211111111110000000000
5687                                                                  10987654321098765432109876543210
5688                                                                  xxxxxxxxxx0101101xxxx1xx0111001x
5689                                                                  fcvtn2.  */
5690                                                               return 161;
5691                                                             }
5692                                                         }
5693                                                       else
5694                                                         {
5695                                                           if (((word >> 30) & 0x1) == 0)
5696                                                             {
5697                                                               /* 33222222222211111111110000000000
5698                                                                  10987654321098765432109876543210
5699                                                                  xxxxxxxxxx0101101xxxx1xx0111010x
5700                                                                  fcvtxn.  */
5701                                                               return 195;
5702                                                             }
5703                                                           else
5704                                                             {
5705                                                               /* 33222222222211111111110000000000
5706                                                                  10987654321098765432109876543210
5707                                                                  xxxxxxxxxx0101101xxxx1xx0111011x
5708                                                                  fcvtxn2.  */
5709                                                               return 196;
5710                                                             }
5711                                                         }
5712                                                     }
5713                                                 }
5714                                               else
5715                                                 {
5716                                                   if (((word >> 29) & 0x1) == 0)
5717                                                     {
5718                                                       /* 33222222222211111111110000000000
5719                                                          10987654321098765432109876543210
5720                                                          xxxxxxxxxx010110xxxxx1xx011110xx
5721                                                          fmaxnm.  */
5722                                                       return 640;
5723                                                     }
5724                                                   else
5725                                                     {
5726                                                       /* 33222222222211111111110000000000
5727                                                          10987654321098765432109876543210
5728                                                          xxxxxxxxxx010110xxxxx1xx011111xx
5729                                                          fcvtxn.  */
5730                                                       return 420;
5731                                                     }
5732                                                 }
5733                                             }
5734                                           else
5735                                             {
5736                                               if (((word >> 28) & 0x1) == 0)
5737                                                 {
5738                                                   /* 33222222222211111111110000000000
5739                                                      10987654321098765432109876543210
5740                                                      xxxxxxxxxx010111xxxxx1xx01110xxx
5741                                                      fcmlt.  */
5742                                                   return 172;
5743                                                 }
5744                                               else
5745                                                 {
5746                                                   /* 33222222222211111111110000000000
5747                                                      10987654321098765432109876543210
5748                                                      xxxxxxxxxx010111xxxxx1xx01111xxx
5749                                                      fcmlt.  */
5750                                                   return 408;
5751                                                 }
5752                                             }
5753                                         }
5754                                     }
5755                                 }
5756                               else
5757                                 {
5758                                   if (((word >> 13) & 0x1) == 0)
5759                                     {
5760                                       if (((word >> 14) & 0x1) == 0)
5761                                         {
5762                                           if (((word >> 15) & 0x1) == 0)
5763                                             {
5764                                               if (((word >> 28) & 0x1) == 0)
5765                                                 {
5766                                                   /* 33222222222211111111110000000000
5767                                                      10987654321098765432109876543210
5768                                                      xxxxxxxxxx011000xxxxx1xx01110xxx
5769                                                      rev16.  */
5770                                                   return 145;
5771                                                 }
5772                                               else
5773                                                 {
5774                                                   if (((word >> 30) & 0x1) == 0)
5775                                                     {
5776                                                       /* 33222222222211111111110000000000
5777                                                          10987654321098765432109876543210
5778                                                          xxxxxxxxxx011000xxxxx1xx01111x0x
5779                                                          fdiv.  */
5780                                                       return 635;
5781                                                     }
5782                                                   else
5783                                                     {
5784                                                       /* 33222222222211111111110000000000
5785                                                          10987654321098765432109876543210
5786                                                          xxxxxxxxxx011000xxxxx1xx01111x1x
5787                                                          sha1su1.  */
5788                                                       return 538;
5789                                                     }
5790                                                 }
5791                                             }
5792                                           else
5793                                             {
5794                                               if (((word >> 16) & 0x1) == 0)
5795                                                 {
5796                                                   if (((word >> 28) & 0x1) == 0)
5797                                                     {
5798                                                       if (((word >> 29) & 0x1) == 0)
5799                                                         {
5800                                                           /* 33222222222211111111110000000000
5801                                                              10987654321098765432109876543210
5802                                                              xxxxxxxxxx0110010xxxx1xx011100xx
5803                                                              cmeq.  */
5804                                                           return 153;
5805                                                         }
5806                                                       else
5807                                                         {
5808                                                           /* 33222222222211111111110000000000
5809                                                              10987654321098765432109876543210
5810                                                              xxxxxxxxxx0110010xxxx1xx011101xx
5811                                                              cmle.  */
5812                                                           return 187;
5813                                                         }
5814                                                     }
5815                                                   else
5816                                                     {
5817                                                       if (((word >> 29) & 0x1) == 0)
5818                                                         {
5819                                                           /* 33222222222211111111110000000000
5820                                                              10987654321098765432109876543210
5821                                                              xxxxxxxxxx0110010xxxx1xx011110xx
5822                                                              cmeq.  */
5823                                                           return 398;
5824                                                         }
5825                                                       else
5826                                                         {
5827                                                           /* 33222222222211111111110000000000
5828                                                              10987654321098765432109876543210
5829                                                              xxxxxxxxxx0110010xxxx1xx011111xx
5830                                                              cmle.  */
5831                                                           return 416;
5832                                                         }
5833                                                     }
5834                                                 }
5835                                               else
5836                                                 {
5837                                                   if (((word >> 23) & 0x1) == 0)
5838                                                     {
5839                                                       if (((word >> 29) & 0x1) == 0)
5840                                                         {
5841                                                           /* 33222222222211111111110000000000
5842                                                              10987654321098765432109876543210
5843                                                              xxxxxxxxxx0110011xxxx1x00111x0xx
5844                                                              frintm.  */
5845                                                           return 165;
5846                                                         }
5847                                                       else
5848                                                         {
5849                                                           /* 33222222222211111111110000000000
5850                                                              10987654321098765432109876543210
5851                                                              xxxxxxxxxx0110011xxxx1x00111x1xx
5852                                                              frintx.  */
5853                                                           return 198;
5854                                                         }
5855                                                     }
5856                                                   else
5857                                                     {
5858                                                       if (((word >> 29) & 0x1) == 0)
5859                                                         {
5860                                                           /* 33222222222211111111110000000000
5861                                                              10987654321098765432109876543210
5862                                                              xxxxxxxxxx0110011xxxx1x10111x0xx
5863                                                              frintz.  */
5864                                                           return 175;
5865                                                         }
5866                                                       else
5867                                                         {
5868                                                           /* 33222222222211111111110000000000
5869                                                              10987654321098765432109876543210
5870                                                              xxxxxxxxxx0110011xxxx1x10111x1xx
5871                                                              frinti.  */
5872                                                           return 209;
5873                                                         }
5874                                                     }
5875                                                 }
5876                                             }
5877                                         }
5878                                       else
5879                                         {
5880                                           if (((word >> 15) & 0x1) == 0)
5881                                             {
5882                                               if (((word >> 28) & 0x1) == 0)
5883                                                 {
5884                                                   if (((word >> 19) & 0x1) == 0)
5885                                                     {
5886                                                       if (((word >> 29) & 0x1) == 0)
5887                                                         {
5888                                                           /* 33222222222211111111110000000000
5889                                                              10987654321098765432109876543210
5890                                                              xxxxxxxxxx011010xxx0x1xx011100xx
5891                                                              cnt.  */
5892                                                           return 149;
5893                                                         }
5894                                                       else
5895                                                         {
5896                                                           if (((word >> 22) & 0x1) == 0)
5897                                                             {
5898                                                               /* 33222222222211111111110000000000
5899                                                                  10987654321098765432109876543210
5900                                                                  xxxxxxxxxx011010xxx0x10x011101xx
5901                                                                  not.  */
5902                                                               return 203;
5903                                                             }
5904                                                           else
5905                                                             {
5906                                                               /* 33222222222211111111110000000000
5907                                                                  10987654321098765432109876543210
5908                                                                  xxxxxxxxxx011010xxx0x11x011101xx
5909                                                                  rbit.  */
5910                                                               return 205;
5911                                                             }
5912                                                         }
5913                                                     }
5914                                                   else
5915                                                     {
5916                                                       /* 33222222222211111111110000000000
5917                                                          10987654321098765432109876543210
5918                                                          xxxxxxxxxx011010xxx1x1xx01110xxx
5919                                                          aesd.  */
5920                                                       return 534;
5921                                                     }
5922                                                 }
5923                                               else
5924                                                 {
5925                                                   /* 33222222222211111111110000000000
5926                                                      10987654321098765432109876543210
5927                                                      xxxxxxxxxx011010xxxxx1xx01111xxx
5928                                                      fmin.  */
5929                                                   return 639;
5930                                                 }
5931                                             }
5932                                           else
5933                                             {
5934                                               if (((word >> 16) & 0x1) == 0)
5935                                                 {
5936                                                   if (((word >> 20) & 0x1) == 0)
5937                                                     {
5938                                                       if (((word >> 28) & 0x1) == 0)
5939                                                         {
5940                                                           if (((word >> 29) & 0x1) == 0)
5941                                                             {
5942                                                               /* 33222222222211111111110000000000
5943                                                                  10987654321098765432109876543210
5944                                                                  xxxxxxxxxx0110110xxx01xx011100xx
5945                                                                  fcmeq.  */
5946                                                               return 171;
5947                                                             }
5948                                                           else
5949                                                             {
5950                                                               /* 33222222222211111111110000000000
5951                                                                  10987654321098765432109876543210
5952                                                                  xxxxxxxxxx0110110xxx01xx011101xx
5953                                                                  fcmle.  */
5954                                                               return 207;
5955                                                             }
5956                                                         }
5957                                                       else
5958                                                         {
5959                                                           if (((word >> 29) & 0x1) == 0)
5960                                                             {
5961                                                               /* 33222222222211111111110000000000
5962                                                                  10987654321098765432109876543210
5963                                                                  xxxxxxxxxx0110110xxx01xx011110xx
5964                                                                  fcmeq.  */
5965                                                               return 407;
5966                                                             }
5967                                                           else
5968                                                             {
5969                                                               /* 33222222222211111111110000000000
5970                                                                  10987654321098765432109876543210
5971                                                                  xxxxxxxxxx0110110xxx01xx011111xx
5972                                                                  fcmle.  */
5973                                                               return 426;
5974                                                             }
5975                                                         }
5976                                                     }
5977                                                   else
5978                                                     {
5979                                                       /* 33222222222211111111110000000000
5980                                                          10987654321098765432109876543210
5981                                                          xxxxxxxxxx0110110xxx11xx0111xxxx
5982                                                          faddp.  */
5983                                                       return 434;
5984                                                     }
5985                                                 }
5986                                               else
5987                                                 {
5988                                                   if (((word >> 23) & 0x1) == 0)
5989                                                     {
5990                                                       if (((word >> 28) & 0x1) == 0)
5991                                                         {
5992                                                           if (((word >> 29) & 0x1) == 0)
5993                                                             {
5994                                                               /* 33222222222211111111110000000000
5995                                                                  10987654321098765432109876543210
5996                                                                  xxxxxxxxxx0110111xxxx1x0011100xx
5997                                                                  scvtf.  */
5998                                                               return 169;
5999                                                             }
6000                                                           else
6001                                                             {
6002                                                               /* 33222222222211111111110000000000
6003                                                                  10987654321098765432109876543210
6004                                                                  xxxxxxxxxx0110111xxxx1x0011101xx
6005                                                                  ucvtf.  */
6006                                                               return 202;
6007                                                             }
6008                                                         }
6009                                                       else
6010                                                         {
6011                                                           if (((word >> 29) & 0x1) == 0)
6012                                                             {
6013                                                               /* 33222222222211111111110000000000
6014                                                                  10987654321098765432109876543210
6015                                                                  xxxxxxxxxx0110111xxxx1x0011110xx
6016                                                                  scvtf.  */
6017                                                               return 405;
6018                                                             }
6019                                                           else
6020                                                             {
6021                                                               /* 33222222222211111111110000000000
6022                                                                  10987654321098765432109876543210
6023                                                                  xxxxxxxxxx0110111xxxx1x0011111xx
6024                                                                  ucvtf.  */
6025                                                               return 424;
6026                                                             }
6027                                                         }
6028                                                     }
6029                                                   else
6030                                                     {
6031                                                       if (((word >> 28) & 0x1) == 0)
6032                                                         {
6033                                                           if (((word >> 29) & 0x1) == 0)
6034                                                             {
6035                                                               /* 33222222222211111111110000000000
6036                                                                  10987654321098765432109876543210
6037                                                                  xxxxxxxxxx0110111xxxx1x1011100xx
6038                                                                  frecpe.  */
6039                                                               return 179;
6040                                                             }
6041                                                           else
6042                                                             {
6043                                                               /* 33222222222211111111110000000000
6044                                                                  10987654321098765432109876543210
6045                                                                  xxxxxxxxxx0110111xxxx1x1011101xx
6046                                                                  frsqrte.  */
6047                                                               return 213;
6048                                                             }
6049                                                         }
6050                                                       else
6051                                                         {
6052                                                           if (((word >> 29) & 0x1) == 0)
6053                                                             {
6054                                                               /* 33222222222211111111110000000000
6055                                                                  10987654321098765432109876543210
6056                                                                  xxxxxxxxxx0110111xxxx1x1011110xx
6057                                                                  frecpe.  */
6058                                                               return 411;
6059                                                             }
6060                                                           else
6061                                                             {
6062                                                               /* 33222222222211111111110000000000
6063                                                                  10987654321098765432109876543210
6064                                                                  xxxxxxxxxx0110111xxxx1x1011111xx
6065                                                                  frsqrte.  */
6066                                                               return 429;
6067                                                             }
6068                                                         }
6069                                                     }
6070                                                 }
6071                                             }
6072                                         }
6073                                     }
6074                                   else
6075                                     {
6076                                       if (((word >> 14) & 0x1) == 0)
6077                                         {
6078                                           if (((word >> 15) & 0x1) == 0)
6079                                             {
6080                                               if (((word >> 28) & 0x1) == 0)
6081                                                 {
6082                                                   if (((word >> 16) & 0x1) == 0)
6083                                                     {
6084                                                       if (((word >> 20) & 0x1) == 0)
6085                                                         {
6086                                                           if (((word >> 29) & 0x1) == 0)
6087                                                             {
6088                                                               /* 33222222222211111111110000000000
6089                                                                  10987654321098765432109876543210
6090                                                                  xxxxxxxxxx0111000xxx01xx011100xx
6091                                                                  suqadd.  */
6092                                                               return 147;
6093                                                             }
6094                                                           else
6095                                                             {
6096                                                               /* 33222222222211111111110000000000
6097                                                                  10987654321098765432109876543210
6098                                                                  xxxxxxxxxx0111000xxx01xx011101xx
6099                                                                  usqadd.  */
6100                                                               return 182;
6101                                                             }
6102                                                         }
6103                                                       else
6104                                                         {
6105                                                           if (((word >> 29) & 0x1) == 0)
6106                                                             {
6107                                                               /* 33222222222211111111110000000000
6108                                                                  10987654321098765432109876543210
6109                                                                  xxxxxxxxxx0111000xxx11xx011100xx
6110                                                                  saddlv.  */
6111                                                               return 27;
6112                                                             }
6113                                                           else
6114                                                             {
6115                                                               /* 33222222222211111111110000000000
6116                                                                  10987654321098765432109876543210
6117                                                                  xxxxxxxxxx0111000xxx11xx011101xx
6118                                                                  uaddlv.  */
6119                                                               return 31;
6120                                                             }
6121                                                         }
6122                                                     }
6123                                                   else
6124                                                     {
6125                                                       if (((word >> 30) & 0x1) == 0)
6126                                                         {
6127                                                           /* 33222222222211111111110000000000
6128                                                              10987654321098765432109876543210
6129                                                              xxxxxxxxxx0111001xxxx1xx01110x0x
6130                                                              shll.  */
6131                                                           return 191;
6132                                                         }
6133                                                       else
6134                                                         {
6135                                                           /* 33222222222211111111110000000000
6136                                                              10987654321098765432109876543210
6137                                                              xxxxxxxxxx0111001xxxx1xx01110x1x
6138                                                              shll2.  */
6139                                                           return 192;
6140                                                         }
6141                                                     }
6142                                                 }
6143                                               else
6144                                                 {
6145                                                   if (((word >> 29) & 0x1) == 0)
6146                                                     {
6147                                                       if (((word >> 30) & 0x1) == 0)
6148                                                         {
6149                                                           /* 33222222222211111111110000000000
6150                                                              10987654321098765432109876543210
6151                                                              xxxxxxxxxx011100xxxxx1xx0111100x
6152                                                              fsub.  */
6153                                                           return 637;
6154                                                         }
6155                                                       else
6156                                                         {
6157                                                           /* 33222222222211111111110000000000
6158                                                              10987654321098765432109876543210
6159                                                              xxxxxxxxxx011100xxxxx1xx0111101x
6160                                                              suqadd.  */
6161                                                           return 395;
6162                                                         }
6163                                                     }
6164                                                   else
6165                                                     {
6166                                                       /* 33222222222211111111110000000000
6167                                                          10987654321098765432109876543210
6168                                                          xxxxxxxxxx011100xxxxx1xx011111xx
6169                                                          usqadd.  */
6170                                                       return 413;
6171                                                     }
6172                                                 }
6173                                             }
6174                                           else
6175                                             {
6176                                               if (((word >> 16) & 0x1) == 0)
6177                                                 {
6178                                                   if (((word >> 28) & 0x1) == 0)
6179                                                     {
6180                                                       if (((word >> 29) & 0x1) == 0)
6181                                                         {
6182                                                           /* 33222222222211111111110000000000
6183                                                              10987654321098765432109876543210
6184                                                              xxxxxxxxxx0111010xxxx1xx011100xx
6185                                                              abs.  */
6186                                                           return 155;
6187                                                         }
6188                                                       else
6189                                                         {
6190                                                           /* 33222222222211111111110000000000
6191                                                              10987654321098765432109876543210
6192                                                              xxxxxxxxxx0111010xxxx1xx011101xx
6193                                                              neg.  */
6194                                                           return 188;
6195                                                         }
6196                                                     }
6197                                                   else
6198                                                     {
6199                                                       if (((word >> 29) & 0x1) == 0)
6200                                                         {
6201                                                           /* 33222222222211111111110000000000
6202                                                              10987654321098765432109876543210
6203                                                              xxxxxxxxxx0111010xxxx1xx011110xx
6204                                                              abs.  */
6205                                                           return 400;
6206                                                         }
6207                                                       else
6208                                                         {
6209                                                           /* 33222222222211111111110000000000
6210                                                              10987654321098765432109876543210
6211                                                              xxxxxxxxxx0111010xxxx1xx011111xx
6212                                                              neg.  */
6213                                                           return 417;
6214                                                         }
6215                                                     }
6216                                                 }
6217                                               else
6218                                                 {
6219                                                   if (((word >> 20) & 0x1) == 0)
6220                                                     {
6221                                                       if (((word >> 23) & 0x1) == 0)
6222                                                         {
6223                                                           if (((word >> 28) & 0x1) == 0)
6224                                                             {
6225                                                               if (((word >> 29) & 0x1) == 0)
6226                                                                 {
6227                                                                   /* 33222222222211111111110000000000
6228                                                                      10987654321098765432109876543210
6229                                                                      xxxxxxxxxx0111011xxx01x0011100xx
6230                                                                      fcvtms.  */
6231                                                                   return 167;
6232                                                                 }
6233                                                               else
6234                                                                 {
6235                                                                   /* 33222222222211111111110000000000
6236                                                                      10987654321098765432109876543210
6237                                                                      xxxxxxxxxx0111011xxx01x0011101xx
6238                                                                      fcvtmu.  */
6239                                                                   return 200;
6240                                                                 }
6241                                                             }
6242                                                           else
6243                                                             {
6244                                                               if (((word >> 29) & 0x1) == 0)
6245                                                                 {
6246                                                                   /* 33222222222211111111110000000000
6247                                                                      10987654321098765432109876543210
6248                                                                      xxxxxxxxxx0111011xxx01x0011110xx
6249                                                                      fcvtms.  */
6250                                                                   return 403;
6251                                                                 }
6252                                                               else
6253                                                                 {
6254                                                                   /* 33222222222211111111110000000000
6255                                                                      10987654321098765432109876543210
6256                                                                      xxxxxxxxxx0111011xxx01x0011111xx
6257                                                                      fcvtmu.  */
6258                                                                   return 422;
6259                                                                 }
6260                                                             }
6261                                                         }
6262                                                       else
6263                                                         {
6264                                                           if (((word >> 28) & 0x1) == 0)
6265                                                             {
6266                                                               if (((word >> 29) & 0x1) == 0)
6267                                                                 {
6268                                                                   /* 33222222222211111111110000000000
6269                                                                      10987654321098765432109876543210
6270                                                                      xxxxxxxxxx0111011xxx01x1011100xx
6271                                                                      fcvtzs.  */
6272                                                                   return 177;
6273                                                                 }
6274                                                               else
6275                                                                 {
6276                                                                   /* 33222222222211111111110000000000
6277                                                                      10987654321098765432109876543210
6278                                                                      xxxxxxxxxx0111011xxx01x1011101xx
6279                                                                      fcvtzu.  */
6280                                                                   return 211;
6281                                                                 }
6282                                                             }
6283                                                           else
6284                                                             {
6285                                                               if (((word >> 29) & 0x1) == 0)
6286                                                                 {
6287                                                                   /* 33222222222211111111110000000000
6288                                                                      10987654321098765432109876543210
6289                                                                      xxxxxxxxxx0111011xxx01x1011110xx
6290                                                                      fcvtzs.  */
6291                                                                   return 410;
6292                                                                 }
6293                                                               else
6294                                                                 {
6295                                                                   /* 33222222222211111111110000000000
6296                                                                      10987654321098765432109876543210
6297                                                                      xxxxxxxxxx0111011xxx01x1011111xx
6298                                                                      fcvtzu.  */
6299                                                                   return 428;
6300                                                                 }
6301                                                             }
6302                                                         }
6303                                                     }
6304                                                   else
6305                                                     {
6306                                                       if (((word >> 28) & 0x1) == 0)
6307                                                         {
6308                                                           /* 33222222222211111111110000000000
6309                                                              10987654321098765432109876543210
6310                                                              xxxxxxxxxx0111011xxx11xx01110xxx
6311                                                              addv.  */
6312                                                           return 30;
6313                                                         }
6314                                                       else
6315                                                         {
6316                                                           /* 33222222222211111111110000000000
6317                                                              10987654321098765432109876543210
6318                                                              xxxxxxxxxx0111011xxx11xx01111xxx
6319                                                              addp.  */
6320                                                           return 432;
6321                                                         }
6322                                                     }
6323                                                 }
6324                                             }
6325                                         }
6326                                       else
6327                                         {
6328                                           if (((word >> 15) & 0x1) == 0)
6329                                             {
6330                                               if (((word >> 28) & 0x1) == 0)
6331                                                 {
6332                                                   if (((word >> 16) & 0x1) == 0)
6333                                                     {
6334                                                       if (((word >> 19) & 0x1) == 0)
6335                                                         {
6336                                                           if (((word >> 29) & 0x1) == 0)
6337                                                             {
6338                                                               /* 33222222222211111111110000000000
6339                                                                  10987654321098765432109876543210
6340                                                                  xxxxxxxxxx0111100xx0x1xx011100xx
6341                                                                  sqabs.  */
6342                                                               return 151;
6343                                                             }
6344                                                           else
6345                                                             {
6346                                                               /* 33222222222211111111110000000000
6347                                                                  10987654321098765432109876543210
6348                                                                  xxxxxxxxxx0111100xx0x1xx011101xx
6349                                                                  sqneg.  */
6350                                                               return 185;
6351                                                             }
6352                                                         }
6353                                                       else
6354                                                         {
6355                                                           /* 33222222222211111111110000000000
6356                                                              10987654321098765432109876543210
6357                                                              xxxxxxxxxx0111100xx1x1xx01110xxx
6358                                                              aesimc.  */
6359                                                           return 536;
6360                                                         }
6361                                                     }
6362                                                   else
6363                                                     {
6364                                                       if (((word >> 30) & 0x1) == 0)
6365                                                         {
6366                                                           /* 33222222222211111111110000000000
6367                                                              10987654321098765432109876543210
6368                                                              xxxxxxxxxx0111101xxxx1xx01110x0x
6369                                                              fcvtl.  */
6370                                                           return 162;
6371                                                         }
6372                                                       else
6373                                                         {
6374                                                           /* 33222222222211111111110000000000
6375                                                              10987654321098765432109876543210
6376                                                              xxxxxxxxxx0111101xxxx1xx01110x1x
6377                                                              fcvtl2.  */
6378                                                           return 163;
6379                                                         }
6380                                                     }
6381                                                 }
6382                                               else
6383                                                 {
6384                                                   if (((word >> 29) & 0x1) == 0)
6385                                                     {
6386                                                       if (((word >> 30) & 0x1) == 0)
6387                                                         {
6388                                                           /* 33222222222211111111110000000000
6389                                                              10987654321098765432109876543210
6390                                                              xxxxxxxxxx011110xxxxx1xx0111100x
6391                                                              fminnm.  */
6392                                                           return 641;
6393                                                         }
6394                                                       else
6395                                                         {
6396                                                           /* 33222222222211111111110000000000
6397                                                              10987654321098765432109876543210
6398                                                              xxxxxxxxxx011110xxxxx1xx0111101x
6399                                                              sqabs.  */
6400                                                           return 396;
6401                                                         }
6402                                                     }
6403                                                   else
6404                                                     {
6405                                                       /* 33222222222211111111110000000000
6406                                                          10987654321098765432109876543210
6407                                                          xxxxxxxxxx011110xxxxx1xx011111xx
6408                                                          sqneg.  */
6409                                                       return 414;
6410                                                     }
6411                                                 }
6412                                             }
6413                                           else
6414                                             {
6415                                               if (((word >> 16) & 0x1) == 0)
6416                                                 {
6417                                                   if (((word >> 20) & 0x1) == 0)
6418                                                     {
6419                                                       if (((word >> 29) & 0x1) == 0)
6420                                                         {
6421                                                           /* 33222222222211111111110000000000
6422                                                              10987654321098765432109876543210
6423                                                              xxxxxxxxxx0111110xxx01xx0111x0xx
6424                                                              fabs.  */
6425                                                           return 173;
6426                                                         }
6427                                                       else
6428                                                         {
6429                                                           /* 33222222222211111111110000000000
6430                                                              10987654321098765432109876543210
6431                                                              xxxxxxxxxx0111110xxx01xx0111x1xx
6432                                                              fneg.  */
6433                                                           return 208;
6434                                                         }
6435                                                     }
6436                                                   else
6437                                                     {
6438                                                       if (((word >> 23) & 0x1) == 0)
6439                                                         {
6440                                                           if (((word >> 28) & 0x1) == 0)
6441                                                             {
6442                                                               /* 33222222222211111111110000000000
6443                                                                  10987654321098765432109876543210
6444                                                                  xxxxxxxxxx0111110xxx11x001110xxx
6445                                                                  fmaxv.  */
6446                                                               return 35;
6447                                                             }
6448                                                           else
6449                                                             {
6450                                                               /* 33222222222211111111110000000000
6451                                                                  10987654321098765432109876543210
6452                                                                  xxxxxxxxxx0111110xxx11x001111xxx
6453                                                                  fmaxp.  */
6454                                                               return 435;
6455                                                             }
6456                                                         }
6457                                                       else
6458                                                         {
6459                                                           if (((word >> 28) & 0x1) == 0)
6460                                                             {
6461                                                               /* 33222222222211111111110000000000
6462                                                                  10987654321098765432109876543210
6463                                                                  xxxxxxxxxx0111110xxx11x101110xxx
6464                                                                  fminv.  */
6465                                                               return 37;
6466                                                             }
6467                                                           else
6468                                                             {
6469                                                               /* 33222222222211111111110000000000
6470                                                                  10987654321098765432109876543210
6471                                                                  xxxxxxxxxx0111110xxx11x101111xxx
6472                                                                  fminp.  */
6473                                                               return 437;
6474                                                             }
6475                                                         }
6476                                                     }
6477                                                 }
6478                                               else
6479                                                 {
6480                                                   if (((word >> 28) & 0x1) == 0)
6481                                                     {
6482                                                       /* 33222222222211111111110000000000
6483                                                          10987654321098765432109876543210
6484                                                          xxxxxxxxxx0111111xxxx1xx01110xxx
6485                                                          fsqrt.  */
6486                                                       return 214;
6487                                                     }
6488                                                   else
6489                                                     {
6490                                                       /* 33222222222211111111110000000000
6491                                                          10987654321098765432109876543210
6492                                                          xxxxxxxxxx0111111xxxx1xx01111xxx
6493                                                          frecpx.  */
6494                                                       return 412;
6495                                                     }
6496                                                 }
6497                                             }
6498                                         }
6499                                     }
6500                                 }
6501                             }
6502                         }
6503                       else
6504                         {
6505                           if (((word >> 11) & 0x1) == 0)
6506                             {
6507                               if (((word >> 28) & 0x1) == 0)
6508                                 {
6509                                   if (((word >> 12) & 0x1) == 0)
6510                                     {
6511                                       if (((word >> 13) & 0x1) == 0)
6512                                         {
6513                                           if (((word >> 14) & 0x1) == 0)
6514                                             {
6515                                               if (((word >> 15) & 0x1) == 0)
6516                                                 {
6517                                                   if (((word >> 29) & 0x1) == 0)
6518                                                     {
6519                                                       /* 33222222222211111111110000000000
6520                                                          10987654321098765432109876543210
6521                                                          xxxxxxxxxx100000xxxxx1xx011100xx
6522                                                          shadd.  */
6523                                                       return 221;
6524                                                     }
6525                                                   else
6526                                                     {
6527                                                       /* 33222222222211111111110000000000
6528                                                          10987654321098765432109876543210
6529                                                          xxxxxxxxxx100000xxxxx1xx011101xx
6530                                                          uhadd.  */
6531                                                       return 261;
6532                                                     }
6533                                                 }
6534                                               else
6535                                                 {
6536                                                   if (((word >> 29) & 0x1) == 0)
6537                                                     {
6538                                                       /* 33222222222211111111110000000000
6539                                                          10987654321098765432109876543210
6540                                                          xxxxxxxxxx100001xxxxx1xx011100xx
6541                                                          add.  */
6542                                                       return 236;
6543                                                     }
6544                                                   else
6545                                                     {
6546                                                       /* 33222222222211111111110000000000
6547                                                          10987654321098765432109876543210
6548                                                          xxxxxxxxxx100001xxxxx1xx011101xx
6549                                                          sub.  */
6550                                                       return 276;
6551                                                     }
6552                                                 }
6553                                             }
6554                                           else
6555                                             {
6556                                               if (((word >> 15) & 0x1) == 0)
6557                                                 {
6558                                                   if (((word >> 29) & 0x1) == 0)
6559                                                     {
6560                                                       /* 33222222222211111111110000000000
6561                                                          10987654321098765432109876543210
6562                                                          xxxxxxxxxx100010xxxxx1xx011100xx
6563                                                          sshl.  */
6564                                                       return 228;
6565                                                     }
6566                                                   else
6567                                                     {
6568                                                       /* 33222222222211111111110000000000
6569                                                          10987654321098765432109876543210
6570                                                          xxxxxxxxxx100010xxxxx1xx011101xx
6571                                                          ushl.  */
6572                                                       return 268;
6573                                                     }
6574                                                 }
6575                                               else
6576                                                 {
6577                                                   if (((word >> 23) & 0x1) == 0)
6578                                                     {
6579                                                       if (((word >> 29) & 0x1) == 0)
6580                                                         {
6581                                                           /* 33222222222211111111110000000000
6582                                                              10987654321098765432109876543210
6583                                                              xxxxxxxxxx100011xxxxx1x0011100xx
6584                                                              fmaxnm.  */
6585                                                           return 244;
6586                                                         }
6587                                                       else
6588                                                         {
6589                                                           /* 33222222222211111111110000000000
6590                                                              10987654321098765432109876543210
6591                                                              xxxxxxxxxx100011xxxxx1x0011101xx
6592                                                              fmaxnmp.  */
6593                                                           return 283;
6594                                                         }
6595                                                     }
6596                                                   else
6597                                                     {
6598                                                       if (((word >> 29) & 0x1) == 0)
6599                                                         {
6600                                                           /* 33222222222211111111110000000000
6601                                                              10987654321098765432109876543210
6602                                                              xxxxxxxxxx100011xxxxx1x1011100xx
6603                                                              fminnm.  */
6604                                                           return 253;
6605                                                         }
6606                                                       else
6607                                                         {
6608                                                           /* 33222222222211111111110000000000
6609                                                              10987654321098765432109876543210
6610                                                              xxxxxxxxxx100011xxxxx1x1011101xx
6611                                                              fminnmp.  */
6612                                                           return 292;
6613                                                         }
6614                                                     }
6615                                                 }
6616                                             }
6617                                         }
6618                                       else
6619                                         {
6620                                           if (((word >> 14) & 0x1) == 0)
6621                                             {
6622                                               if (((word >> 15) & 0x1) == 0)
6623                                                 {
6624                                                   if (((word >> 29) & 0x1) == 0)
6625                                                     {
6626                                                       /* 33222222222211111111110000000000
6627                                                          10987654321098765432109876543210
6628                                                          xxxxxxxxxx100100xxxxx1xx011100xx
6629                                                          shsub.  */
6630                                                       return 224;
6631                                                     }
6632                                                   else
6633                                                     {
6634                                                       /* 33222222222211111111110000000000
6635                                                          10987654321098765432109876543210
6636                                                          xxxxxxxxxx100100xxxxx1xx011101xx
6637                                                          uhsub.  */
6638                                                       return 264;
6639                                                     }
6640                                                 }
6641                                               else
6642                                                 {
6643                                                   if (((word >> 29) & 0x1) == 0)
6644                                                     {
6645                                                       /* 33222222222211111111110000000000
6646                                                          10987654321098765432109876543210
6647                                                          xxxxxxxxxx100101xxxxx1xx011100xx
6648                                                          smaxp.  */
6649                                                       return 240;
6650                                                     }
6651                                                   else
6652                                                     {
6653                                                       /* 33222222222211111111110000000000
6654                                                          10987654321098765432109876543210
6655                                                          xxxxxxxxxx100101xxxxx1xx011101xx
6656                                                          umaxp.  */
6657                                                       return 280;
6658                                                     }
6659                                                 }
6660                                             }
6661                                           else
6662                                             {
6663                                               if (((word >> 15) & 0x1) == 0)
6664                                                 {
6665                                                   if (((word >> 29) & 0x1) == 0)
6666                                                     {
6667                                                       /* 33222222222211111111110000000000
6668                                                          10987654321098765432109876543210
6669                                                          xxxxxxxxxx100110xxxxx1xx011100xx
6670                                                          smax.  */
6671                                                       return 232;
6672                                                     }
6673                                                   else
6674                                                     {
6675                                                       /* 33222222222211111111110000000000
6676                                                          10987654321098765432109876543210
6677                                                          xxxxxxxxxx100110xxxxx1xx011101xx
6678                                                          umax.  */
6679                                                       return 272;
6680                                                     }
6681                                                 }
6682                                               else
6683                                                 {
6684                                                   if (((word >> 23) & 0x1) == 0)
6685                                                     {
6686                                                       if (((word >> 29) & 0x1) == 0)
6687                                                         {
6688                                                           /* 33222222222211111111110000000000
6689                                                              10987654321098765432109876543210
6690                                                              xxxxxxxxxx100111xxxxx1x0011100xx
6691                                                              fcmeq.  */
6692                                                           return 248;
6693                                                         }
6694                                                       else
6695                                                         {
6696                                                           /* 33222222222211111111110000000000
6697                                                              10987654321098765432109876543210
6698                                                              xxxxxxxxxx100111xxxxx1x0011101xx
6699                                                              fcmge.  */
6700                                                           return 286;
6701                                                         }
6702                                                     }
6703                                                   else
6704                                                     {
6705                                                       /* 33222222222211111111110000000000
6706                                                          10987654321098765432109876543210
6707                                                          xxxxxxxxxx100111xxxxx1x101110xxx
6708                                                          fcmgt.  */
6709                                                       return 294;
6710                                                     }
6711                                                 }
6712                                             }
6713                                         }
6714                                     }
6715                                   else
6716                                     {
6717                                       if (((word >> 13) & 0x1) == 0)
6718                                         {
6719                                           if (((word >> 14) & 0x1) == 0)
6720                                             {
6721                                               if (((word >> 15) & 0x1) == 0)
6722                                                 {
6723                                                   if (((word >> 29) & 0x1) == 0)
6724                                                     {
6725                                                       /* 33222222222211111111110000000000
6726                                                          10987654321098765432109876543210
6727                                                          xxxxxxxxxx101000xxxxx1xx011100xx
6728                                                          srhadd.  */
6729                                                       return 223;
6730                                                     }
6731                                                   else
6732                                                     {
6733                                                       /* 33222222222211111111110000000000
6734                                                          10987654321098765432109876543210
6735                                                          xxxxxxxxxx101000xxxxx1xx011101xx
6736                                                          urhadd.  */
6737                                                       return 263;
6738                                                     }
6739                                                 }
6740                                               else
6741                                                 {
6742                                                   if (((word >> 29) & 0x1) == 0)
6743                                                     {
6744                                                       /* 33222222222211111111110000000000
6745                                                          10987654321098765432109876543210
6746                                                          xxxxxxxxxx101001xxxxx1xx011100xx
6747                                                          mla.  */
6748                                                       return 238;
6749                                                     }
6750                                                   else
6751                                                     {
6752                                                       /* 33222222222211111111110000000000
6753                                                          10987654321098765432109876543210
6754                                                          xxxxxxxxxx101001xxxxx1xx011101xx
6755                                                          mls.  */
6756                                                       return 278;
6757                                                     }
6758                                                 }
6759                                             }
6760                                           else
6761                                             {
6762                                               if (((word >> 15) & 0x1) == 0)
6763                                                 {
6764                                                   if (((word >> 29) & 0x1) == 0)
6765                                                     {
6766                                                       /* 33222222222211111111110000000000
6767                                                          10987654321098765432109876543210
6768                                                          xxxxxxxxxx101010xxxxx1xx011100xx
6769                                                          srshl.  */
6770                                                       return 230;
6771                                                     }
6772                                                   else
6773                                                     {
6774                                                       /* 33222222222211111111110000000000
6775                                                          10987654321098765432109876543210
6776                                                          xxxxxxxxxx101010xxxxx1xx011101xx
6777                                                          urshl.  */
6778                                                       return 270;
6779                                                     }
6780                                                 }
6781                                               else
6782                                                 {
6783                                                   if (((word >> 23) & 0x1) == 0)
6784                                                     {
6785                                                       if (((word >> 29) & 0x1) == 0)
6786                                                         {
6787                                                           /* 33222222222211111111110000000000
6788                                                              10987654321098765432109876543210
6789                                                              xxxxxxxxxx101011xxxxx1x0011100xx
6790                                                              fadd.  */
6791                                                           return 246;
6792                                                         }
6793                                                       else
6794                                                         {
6795                                                           /* 33222222222211111111110000000000
6796                                                              10987654321098765432109876543210
6797                                                              xxxxxxxxxx101011xxxxx1x0011101xx
6798                                                              faddp.  */
6799                                                           return 284;
6800                                                         }
6801                                                     }
6802                                                   else
6803                                                     {
6804                                                       if (((word >> 29) & 0x1) == 0)
6805                                                         {
6806                                                           /* 33222222222211111111110000000000
6807                                                              10987654321098765432109876543210
6808                                                              xxxxxxxxxx101011xxxxx1x1011100xx
6809                                                              fsub.  */
6810                                                           return 255;
6811                                                         }
6812                                                       else
6813                                                         {
6814                                                           /* 33222222222211111111110000000000
6815                                                              10987654321098765432109876543210
6816                                                              xxxxxxxxxx101011xxxxx1x1011101xx
6817                                                              fabd.  */
6818                                                           return 293;
6819                                                         }
6820                                                     }
6821                                                 }
6822                                             }
6823                                         }
6824                                       else
6825                                         {
6826                                           if (((word >> 14) & 0x1) == 0)
6827                                             {
6828                                               if (((word >> 15) & 0x1) == 0)
6829                                                 {
6830                                                   if (((word >> 29) & 0x1) == 0)
6831                                                     {
6832                                                       /* 33222222222211111111110000000000
6833                                                          10987654321098765432109876543210
6834                                                          xxxxxxxxxx101100xxxxx1xx011100xx
6835                                                          cmgt.  */
6836                                                       return 226;
6837                                                     }
6838                                                   else
6839                                                     {
6840                                                       /* 33222222222211111111110000000000
6841                                                          10987654321098765432109876543210
6842                                                          xxxxxxxxxx101100xxxxx1xx011101xx
6843                                                          cmhi.  */
6844                                                       return 266;
6845                                                     }
6846                                                 }
6847                                               else
6848                                                 {
6849                                                   if (((word >> 29) & 0x1) == 0)
6850                                                     {
6851                                                       /* 33222222222211111111110000000000
6852                                                          10987654321098765432109876543210
6853                                                          xxxxxxxxxx101101xxxxx1xx011100xx
6854                                                          sqdmulh.  */
6855                                                       return 242;
6856                                                     }
6857                                                   else
6858                                                     {
6859                                                       /* 33222222222211111111110000000000
6860                                                          10987654321098765432109876543210
6861                                                          xxxxxxxxxx101101xxxxx1xx011101xx
6862                                                          sqrdmulh.  */
6863                                                       return 282;
6864                                                     }
6865                                                 }
6866                                             }
6867                                           else
6868                                             {
6869                                               if (((word >> 15) & 0x1) == 0)
6870                                                 {
6871                                                   if (((word >> 29) & 0x1) == 0)
6872                                                     {
6873                                                       /* 33222222222211111111110000000000
6874                                                          10987654321098765432109876543210
6875                                                          xxxxxxxxxx101110xxxxx1xx011100xx
6876                                                          sabd.  */
6877                                                       return 234;
6878                                                     }
6879                                                   else
6880                                                     {
6881                                                       /* 33222222222211111111110000000000
6882                                                          10987654321098765432109876543210
6883                                                          xxxxxxxxxx101110xxxxx1xx011101xx
6884                                                          uabd.  */
6885                                                       return 274;
6886                                                     }
6887                                                 }
6888                                               else
6889                                                 {
6890                                                   if (((word >> 23) & 0x1) == 0)
6891                                                     {
6892                                                       if (((word >> 29) & 0x1) == 0)
6893                                                         {
6894                                                           /* 33222222222211111111110000000000
6895                                                              10987654321098765432109876543210
6896                                                              xxxxxxxxxx101111xxxxx1x0011100xx
6897                                                              fmax.  */
6898                                                           return 249;
6899                                                         }
6900                                                       else
6901                                                         {
6902                                                           /* 33222222222211111111110000000000
6903                                                              10987654321098765432109876543210
6904                                                              xxxxxxxxxx101111xxxxx1x0011101xx
6905                                                              fmaxp.  */
6906                                                           return 288;
6907                                                         }
6908                                                     }
6909                                                   else
6910                                                     {
6911                                                       if (((word >> 29) & 0x1) == 0)
6912                                                         {
6913                                                           /* 33222222222211111111110000000000
6914                                                              10987654321098765432109876543210
6915                                                              xxxxxxxxxx101111xxxxx1x1011100xx
6916                                                              fmin.  */
6917                                                           return 256;
6918                                                         }
6919                                                       else
6920                                                         {
6921                                                           /* 33222222222211111111110000000000
6922                                                              10987654321098765432109876543210
6923                                                              xxxxxxxxxx101111xxxxx1x1011101xx
6924                                                              fminp.  */
6925                                                           return 296;
6926                                                         }
6927                                                     }
6928                                                 }
6929                                             }
6930                                         }
6931                                     }
6932                                 }
6933                               else
6934                                 {
6935                                   if (((word >> 29) & 0x1) == 0)
6936                                     {
6937                                       if (((word >> 30) & 0x1) == 0)
6938                                         {
6939                                           if (((word >> 4) & 0x1) == 0)
6940                                             {
6941                                               /* 33222222222211111111110000000000
6942                                                  10987654321098765432109876543210
6943                                                  xxxx0xxxxx10xxxxxxxxx1xx0111100x
6944                                                  fccmp.  */
6945                                               return 616;
6946                                             }
6947                                           else
6948                                             {
6949                                               /* 33222222222211111111110000000000
6950                                                  10987654321098765432109876543210
6951                                                  xxxx1xxxxx10xxxxxxxxx1xx0111100x
6952                                                  fccmpe.  */
6953                                               return 617;
6954                                             }
6955                                         }
6956                                       else
6957                                         {
6958                                           if (((word >> 12) & 0x1) == 0)
6959                                             {
6960                                               if (((word >> 13) & 0x1) == 0)
6961                                                 {
6962                                                   if (((word >> 14) & 0x1) == 0)
6963                                                     {
6964                                                       /* 33222222222211111111110000000000
6965                                                          10987654321098765432109876543210
6966                                                          xxxxxxxxxx10000xxxxxx1xx0111101x
6967                                                          add.  */
6968                                                       return 451;
6969                                                     }
6970                                                   else
6971                                                     {
6972                                                       /* 33222222222211111111110000000000
6973                                                          10987654321098765432109876543210
6974                                                          xxxxxxxxxx10001xxxxxx1xx0111101x
6975                                                          sshl.  */
6976                                                       return 449;
6977                                                     }
6978                                                 }
6979                                               else
6980                                                 {
6981                                                   /* 33222222222211111111110000000000
6982                                                      10987654321098765432109876543210
6983                                                      xxxxxxxxxx1001xxxxxxx1xx0111101x
6984                                                      fcmeq.  */
6985                                                   return 444;
6986                                                 }
6987                                             }
6988                                           else
6989                                             {
6990                                               if (((word >> 13) & 0x1) == 0)
6991                                                 {
6992                                                   /* 33222222222211111111110000000000
6993                                                      10987654321098765432109876543210
6994                                                      xxxxxxxxxx1010xxxxxxx1xx0111101x
6995                                                      srshl.  */
6996                                                   return 450;
6997                                                 }
6998                                               else
6999                                                 {
7000                                                   if (((word >> 15) & 0x1) == 0)
7001                                                     {
7002                                                       /* 33222222222211111111110000000000
7003                                                          10987654321098765432109876543210
7004                                                          xxxxxxxxxx1011x0xxxxx1xx0111101x
7005                                                          cmgt.  */
7006                                                       return 447;
7007                                                     }
7008                                                   else
7009                                                     {
7010                                                       /* 33222222222211111111110000000000
7011                                                          10987654321098765432109876543210
7012                                                          xxxxxxxxxx1011x1xxxxx1xx0111101x
7013                                                          sqdmulh.  */
7014                                                       return 442;
7015                                                     }
7016                                                 }
7017                                             }
7018                                         }
7019                                     }
7020                                   else
7021                                     {
7022                                       if (((word >> 12) & 0x1) == 0)
7023                                         {
7024                                           if (((word >> 13) & 0x1) == 0)
7025                                             {
7026                                               if (((word >> 14) & 0x1) == 0)
7027                                                 {
7028                                                   /* 33222222222211111111110000000000
7029                                                      10987654321098765432109876543210
7030                                                      xxxxxxxxxx10000xxxxxx1xx011111xx
7031                                                      sub.  */
7032                                                   return 467;
7033                                                 }
7034                                               else
7035                                                 {
7036                                                   /* 33222222222211111111110000000000
7037                                                      10987654321098765432109876543210
7038                                                      xxxxxxxxxx10001xxxxxx1xx011111xx
7039                                                      ushl.  */
7040                                                   return 465;
7041                                                 }
7042                                             }
7043                                           else
7044                                             {
7045                                               if (((word >> 23) & 0x1) == 0)
7046                                                 {
7047                                                   /* 33222222222211111111110000000000
7048                                                      10987654321098765432109876543210
7049                                                      xxxxxxxxxx1001xxxxxxx1x0011111xx
7050                                                      fcmge.  */
7051                                                   return 458;
7052                                                 }
7053                                               else
7054                                                 {
7055                                                   /* 33222222222211111111110000000000
7056                                                      10987654321098765432109876543210
7057                                                      xxxxxxxxxx1001xxxxxxx1x1011111xx
7058                                                      fcmgt.  */
7059                                                   return 461;
7060                                                 }
7061                                             }
7062                                         }
7063                                       else
7064                                         {
7065                                           if (((word >> 13) & 0x1) == 0)
7066                                             {
7067                                               if (((word >> 15) & 0x1) == 0)
7068                                                 {
7069                                                   /* 33222222222211111111110000000000
7070                                                      10987654321098765432109876543210
7071                                                      xxxxxxxxxx1010x0xxxxx1xx011111xx
7072                                                      urshl.  */
7073                                                   return 466;
7074                                                 }
7075                                               else
7076                                                 {
7077                                                   /* 33222222222211111111110000000000
7078                                                      10987654321098765432109876543210
7079                                                      xxxxxxxxxx1010x1xxxxx1xx011111xx
7080                                                      fabd.  */
7081                                                   return 460;
7082                                                 }
7083                                             }
7084                                           else
7085                                             {
7086                                               if (((word >> 15) & 0x1) == 0)
7087                                                 {
7088                                                   /* 33222222222211111111110000000000
7089                                                      10987654321098765432109876543210
7090                                                      xxxxxxxxxx1011x0xxxxx1xx011111xx
7091                                                      cmhi.  */
7092                                                   return 463;
7093                                                 }
7094                                               else
7095                                                 {
7096                                                   /* 33222222222211111111110000000000
7097                                                      10987654321098765432109876543210
7098                                                      xxxxxxxxxx1011x1xxxxx1xx011111xx
7099                                                      sqrdmulh.  */
7100                                                   return 457;
7101                                                 }
7102                                             }
7103                                         }
7104                                     }
7105                                 }
7106                             }
7107                           else
7108                             {
7109                               if (((word >> 28) & 0x1) == 0)
7110                                 {
7111                                   if (((word >> 12) & 0x1) == 0)
7112                                     {
7113                                       if (((word >> 13) & 0x1) == 0)
7114                                         {
7115                                           if (((word >> 14) & 0x1) == 0)
7116                                             {
7117                                               if (((word >> 15) & 0x1) == 0)
7118                                                 {
7119                                                   if (((word >> 29) & 0x1) == 0)
7120                                                     {
7121                                                       /* 33222222222211111111110000000000
7122                                                          10987654321098765432109876543210
7123                                                          xxxxxxxxxx110000xxxxx1xx011100xx
7124                                                          sqadd.  */
7125                                                       return 222;
7126                                                     }
7127                                                   else
7128                                                     {
7129                                                       /* 33222222222211111111110000000000
7130                                                          10987654321098765432109876543210
7131                                                          xxxxxxxxxx110000xxxxx1xx011101xx
7132                                                          uqadd.  */
7133                                                       return 262;
7134                                                     }
7135                                                 }
7136                                               else
7137                                                 {
7138                                                   if (((word >> 29) & 0x1) == 0)
7139                                                     {
7140                                                       /* 33222222222211111111110000000000
7141                                                          10987654321098765432109876543210
7142                                                          xxxxxxxxxx110001xxxxx1xx011100xx
7143                                                          cmtst.  */
7144                                                       return 237;
7145                                                     }
7146                                                   else
7147                                                     {
7148                                                       /* 33222222222211111111110000000000
7149                                                          10987654321098765432109876543210
7150                                                          xxxxxxxxxx110001xxxxx1xx011101xx
7151                                                          cmeq.  */
7152                                                       return 277;
7153                                                     }
7154                                                 }
7155                                             }
7156                                           else
7157                                             {
7158                                               if (((word >> 15) & 0x1) == 0)
7159                                                 {
7160                                                   if (((word >> 29) & 0x1) == 0)
7161                                                     {
7162                                                       /* 33222222222211111111110000000000
7163                                                          10987654321098765432109876543210
7164                                                          xxxxxxxxxx110010xxxxx1xx011100xx
7165                                                          sqshl.  */
7166                                                       return 229;
7167                                                     }
7168                                                   else
7169                                                     {
7170                                                       /* 33222222222211111111110000000000
7171                                                          10987654321098765432109876543210
7172                                                          xxxxxxxxxx110010xxxxx1xx011101xx
7173                                                          uqshl.  */
7174                                                       return 269;
7175                                                     }
7176                                                 }
7177                                               else
7178                                                 {
7179                                                   if (((word >> 23) & 0x1) == 0)
7180                                                     {
7181                                                       /* 33222222222211111111110000000000
7182                                                          10987654321098765432109876543210
7183                                                          xxxxxxxxxx110011xxxxx1x001110xxx
7184                                                          fmla.  */
7185                                                       return 245;
7186                                                     }
7187                                                   else
7188                                                     {
7189                                                       /* 33222222222211111111110000000000
7190                                                          10987654321098765432109876543210
7191                                                          xxxxxxxxxx110011xxxxx1x101110xxx
7192                                                          fmls.  */
7193                                                       return 254;
7194                                                     }
7195                                                 }
7196                                             }
7197                                         }
7198                                       else
7199                                         {
7200                                           if (((word >> 14) & 0x1) == 0)
7201                                             {
7202                                               if (((word >> 15) & 0x1) == 0)
7203                                                 {
7204                                                   if (((word >> 29) & 0x1) == 0)
7205                                                     {
7206                                                       /* 33222222222211111111110000000000
7207                                                          10987654321098765432109876543210
7208                                                          xxxxxxxxxx110100xxxxx1xx011100xx
7209                                                          sqsub.  */
7210                                                       return 225;
7211                                                     }
7212                                                   else
7213                                                     {
7214                                                       /* 33222222222211111111110000000000
7215                                                          10987654321098765432109876543210
7216                                                          xxxxxxxxxx110100xxxxx1xx011101xx
7217                                                          uqsub.  */
7218                                                       return 265;
7219                                                     }
7220                                                 }
7221                                               else
7222                                                 {
7223                                                   if (((word >> 29) & 0x1) == 0)
7224                                                     {
7225                                                       /* 33222222222211111111110000000000
7226                                                          10987654321098765432109876543210
7227                                                          xxxxxxxxxx110101xxxxx1xx011100xx
7228                                                          sminp.  */
7229                                                       return 241;
7230                                                     }
7231                                                   else
7232                                                     {
7233                                                       /* 33222222222211111111110000000000
7234                                                          10987654321098765432109876543210
7235                                                          xxxxxxxxxx110101xxxxx1xx011101xx
7236                                                          uminp.  */
7237                                                       return 281;
7238                                                     }
7239                                                 }
7240                                             }
7241                                           else
7242                                             {
7243                                               if (((word >> 15) & 0x1) == 0)
7244                                                 {
7245                                                   if (((word >> 29) & 0x1) == 0)
7246                                                     {
7247                                                       /* 33222222222211111111110000000000
7248                                                          10987654321098765432109876543210
7249                                                          xxxxxxxxxx110110xxxxx1xx011100xx
7250                                                          smin.  */
7251                                                       return 233;
7252                                                     }
7253                                                   else
7254                                                     {
7255                                                       /* 33222222222211111111110000000000
7256                                                          10987654321098765432109876543210
7257                                                          xxxxxxxxxx110110xxxxx1xx011101xx
7258                                                          umin.  */
7259                                                       return 273;
7260                                                     }
7261                                                 }
7262                                               else
7263                                                 {
7264                                                   if (((word >> 23) & 0x1) == 0)
7265                                                     {
7266                                                       /* 33222222222211111111110000000000
7267                                                          10987654321098765432109876543210
7268                                                          xxxxxxxxxx110111xxxxx1x001110xxx
7269                                                          facge.  */
7270                                                       return 287;
7271                                                     }
7272                                                   else
7273                                                     {
7274                                                       /* 33222222222211111111110000000000
7275                                                          10987654321098765432109876543210
7276                                                          xxxxxxxxxx110111xxxxx1x101110xxx
7277                                                          facgt.  */
7278                                                       return 295;
7279                                                     }
7280                                                 }
7281                                             }
7282                                         }
7283                                     }
7284                                   else
7285                                     {
7286                                       if (((word >> 13) & 0x1) == 0)
7287                                         {
7288                                           if (((word >> 14) & 0x1) == 0)
7289                                             {
7290                                               if (((word >> 15) & 0x1) == 0)
7291                                                 {
7292                                                   if (((word >> 22) & 0x1) == 0)
7293                                                     {
7294                                                       if (((word >> 23) & 0x1) == 0)
7295                                                         {
7296                                                           if (((word >> 29) & 0x1) == 0)
7297                                                             {
7298                                                               /* 33222222222211111111110000000000
7299                                                                  10987654321098765432109876543210
7300                                                                  xxxxxxxxxx111000xxxxx100011100xx
7301                                                                  and.  */
7302                                                               return 251;
7303                                                             }
7304                                                           else
7305                                                             {
7306                                                               /* 33222222222211111111110000000000
7307                                                                  10987654321098765432109876543210
7308                                                                  xxxxxxxxxx111000xxxxx100011101xx
7309                                                                  eor.  */
7310                                                               return 290;
7311                                                             }
7312                                                         }
7313                                                       else
7314                                                         {
7315                                                           if (((word >> 29) & 0x1) == 0)
7316                                                             {
7317                                                               /* 33222222222211111111110000000000
7318                                                                  10987654321098765432109876543210
7319                                                                  xxxxxxxxxx111000xxxxx101011100xx
7320                                                                  orr.  */
7321                                                               return 258;
7322                                                             }
7323                                                           else
7324                                                             {
7325                                                               /* 33222222222211111111110000000000
7326                                                                  10987654321098765432109876543210
7327                                                                  xxxxxxxxxx111000xxxxx101011101xx
7328                                                                  bit.  */
7329                                                               return 297;
7330                                                             }
7331                                                         }
7332                                                     }
7333                                                   else
7334                                                     {
7335                                                       if (((word >> 23) & 0x1) == 0)
7336                                                         {
7337                                                           if (((word >> 29) & 0x1) == 0)
7338                                                             {
7339                                                               /* 33222222222211111111110000000000
7340                                                                  10987654321098765432109876543210
7341                                                                  xxxxxxxxxx111000xxxxx110011100xx
7342                                                                  bic.  */
7343                                                               return 252;
7344                                                             }
7345                                                           else
7346                                                             {
7347                                                               /* 33222222222211111111110000000000
7348                                                                  10987654321098765432109876543210
7349                                                                  xxxxxxxxxx111000xxxxx110011101xx
7350                                                                  bsl.  */
7351                                                               return 291;
7352                                                             }
7353                                                         }
7354                                                       else
7355                                                         {
7356                                                           if (((word >> 29) & 0x1) == 0)
7357                                                             {
7358                                                               /* 33222222222211111111110000000000
7359                                                                  10987654321098765432109876543210
7360                                                                  xxxxxxxxxx111000xxxxx111011100xx
7361                                                                  orn.  */
7362                                                               return 260;
7363                                                             }
7364                                                           else
7365                                                             {
7366                                                               /* 33222222222211111111110000000000
7367                                                                  10987654321098765432109876543210
7368                                                                  xxxxxxxxxx111000xxxxx111011101xx
7369                                                                  bif.  */
7370                                                               return 298;
7371                                                             }
7372                                                         }
7373                                                     }
7374                                                 }
7375                                               else
7376                                                 {
7377                                                   if (((word >> 29) & 0x1) == 0)
7378                                                     {
7379                                                       /* 33222222222211111111110000000000
7380                                                          10987654321098765432109876543210
7381                                                          xxxxxxxxxx111001xxxxx1xx011100xx
7382                                                          mul.  */
7383                                                       return 239;
7384                                                     }
7385                                                   else
7386                                                     {
7387                                                       /* 33222222222211111111110000000000
7388                                                          10987654321098765432109876543210
7389                                                          xxxxxxxxxx111001xxxxx1xx011101xx
7390                                                          pmul.  */
7391                                                       return 279;
7392                                                     }
7393                                                 }
7394                                             }
7395                                           else
7396                                             {
7397                                               if (((word >> 15) & 0x1) == 0)
7398                                                 {
7399                                                   if (((word >> 29) & 0x1) == 0)
7400                                                     {
7401                                                       /* 33222222222211111111110000000000
7402                                                          10987654321098765432109876543210
7403                                                          xxxxxxxxxx111010xxxxx1xx011100xx
7404                                                          sqrshl.  */
7405                                                       return 231;
7406                                                     }
7407                                                   else
7408                                                     {
7409                                                       /* 33222222222211111111110000000000
7410                                                          10987654321098765432109876543210
7411                                                          xxxxxxxxxx111010xxxxx1xx011101xx
7412                                                          uqrshl.  */
7413                                                       return 271;
7414                                                     }
7415                                                 }
7416                                               else
7417                                                 {
7418                                                   if (((word >> 29) & 0x1) == 0)
7419                                                     {
7420                                                       /* 33222222222211111111110000000000
7421                                                          10987654321098765432109876543210
7422                                                          xxxxxxxxxx111011xxxxx1xx011100xx
7423                                                          fmulx.  */
7424                                                       return 247;
7425                                                     }
7426                                                   else
7427                                                     {
7428                                                       /* 33222222222211111111110000000000
7429                                                          10987654321098765432109876543210
7430                                                          xxxxxxxxxx111011xxxxx1xx011101xx
7431                                                          fmul.  */
7432                                                       return 285;
7433                                                     }
7434                                                 }
7435                                             }
7436                                         }
7437                                       else
7438                                         {
7439                                           if (((word >> 14) & 0x1) == 0)
7440                                             {
7441                                               if (((word >> 15) & 0x1) == 0)
7442                                                 {
7443                                                   if (((word >> 29) & 0x1) == 0)
7444                                                     {
7445                                                       /* 33222222222211111111110000000000
7446                                                          10987654321098765432109876543210
7447                                                          xxxxxxxxxx111100xxxxx1xx011100xx
7448                                                          cmge.  */
7449                                                       return 227;
7450                                                     }
7451                                                   else
7452                                                     {
7453                                                       /* 33222222222211111111110000000000
7454                                                          10987654321098765432109876543210
7455                                                          xxxxxxxxxx111100xxxxx1xx011101xx
7456                                                          cmhs.  */
7457                                                       return 267;
7458                                                     }
7459                                                 }
7460                                               else
7461                                                 {
7462                                                   /* 33222222222211111111110000000000
7463                                                      10987654321098765432109876543210
7464                                                      xxxxxxxxxx111101xxxxx1xx01110xxx
7465                                                      addp.  */
7466                                                   return 243;
7467                                                 }
7468                                             }
7469                                           else
7470                                             {
7471                                               if (((word >> 15) & 0x1) == 0)
7472                                                 {
7473                                                   if (((word >> 29) & 0x1) == 0)
7474                                                     {
7475                                                       /* 33222222222211111111110000000000
7476                                                          10987654321098765432109876543210
7477                                                          xxxxxxxxxx111110xxxxx1xx011100xx
7478                                                          saba.  */
7479                                                       return 235;
7480                                                     }
7481                                                   else
7482                                                     {
7483                                                       /* 33222222222211111111110000000000
7484                                                          10987654321098765432109876543210
7485                                                          xxxxxxxxxx111110xxxxx1xx011101xx
7486                                                          uaba.  */
7487                                                       return 275;
7488                                                     }
7489                                                 }
7490                                               else
7491                                                 {
7492                                                   if (((word >> 23) & 0x1) == 0)
7493                                                     {
7494                                                       if (((word >> 29) & 0x1) == 0)
7495                                                         {
7496                                                           /* 33222222222211111111110000000000
7497                                                              10987654321098765432109876543210
7498                                                              xxxxxxxxxx111111xxxxx1x0011100xx
7499                                                              frecps.  */
7500                                                           return 250;
7501                                                         }
7502                                                       else
7503                                                         {
7504                                                           /* 33222222222211111111110000000000
7505                                                              10987654321098765432109876543210
7506                                                              xxxxxxxxxx111111xxxxx1x0011101xx
7507                                                              fdiv.  */
7508                                                           return 289;
7509                                                         }
7510                                                     }
7511                                                   else
7512                                                     {
7513                                                       /* 33222222222211111111110000000000
7514                                                          10987654321098765432109876543210
7515                                                          xxxxxxxxxx111111xxxxx1x101110xxx
7516                                                          frsqrts.  */
7517                                                       return 257;
7518                                                     }
7519                                                 }
7520                                             }
7521                                         }
7522                                     }
7523                                 }
7524                               else
7525                                 {
7526                                   if (((word >> 29) & 0x1) == 0)
7527                                     {
7528                                       if (((word >> 30) & 0x1) == 0)
7529                                         {
7530                                           /* 33222222222211111111110000000000
7531                                              10987654321098765432109876543210
7532                                              xxxxxxxxxx11xxxxxxxxx1xx0111100x
7533                                              fcsel.  */
7534                                           return 648;
7535                                         }
7536                                       else
7537                                         {
7538                                           if (((word >> 12) & 0x1) == 0)
7539                                             {
7540                                               if (((word >> 13) & 0x1) == 0)
7541                                                 {
7542                                                   if (((word >> 14) & 0x1) == 0)
7543                                                     {
7544                                                       if (((word >> 15) & 0x1) == 0)
7545                                                         {
7546                                                           /* 33222222222211111111110000000000
7547                                                              10987654321098765432109876543210
7548                                                              xxxxxxxxxx110000xxxxx1xx0111101x
7549                                                              sqadd.  */
7550                                                           return 438;
7551                                                         }
7552                                                       else
7553                                                         {
7554                                                           /* 33222222222211111111110000000000
7555                                                              10987654321098765432109876543210
7556                                                              xxxxxxxxxx110001xxxxx1xx0111101x
7557                                                              cmtst.  */
7558                                                           return 452;
7559                                                         }
7560                                                     }
7561                                                   else
7562                                                     {
7563                                                       /* 33222222222211111111110000000000
7564                                                          10987654321098765432109876543210
7565                                                          xxxxxxxxxx11001xxxxxx1xx0111101x
7566                                                          sqshl.  */
7567                                                       return 440;
7568                                                     }
7569                                                 }
7570                                               else
7571                                                 {
7572                                                   /* 33222222222211111111110000000000
7573                                                      10987654321098765432109876543210
7574                                                      xxxxxxxxxx1101xxxxxxx1xx0111101x
7575                                                      sqsub.  */
7576                                                   return 439;
7577                                                 }
7578                                             }
7579                                           else
7580                                             {
7581                                               if (((word >> 13) & 0x1) == 0)
7582                                                 {
7583                                                   if (((word >> 15) & 0x1) == 0)
7584                                                     {
7585                                                       /* 33222222222211111111110000000000
7586                                                          10987654321098765432109876543210
7587                                                          xxxxxxxxxx1110x0xxxxx1xx0111101x
7588                                                          sqrshl.  */
7589                                                       return 441;
7590                                                     }
7591                                                   else
7592                                                     {
7593                                                       /* 33222222222211111111110000000000
7594                                                          10987654321098765432109876543210
7595                                                          xxxxxxxxxx1110x1xxxxx1xx0111101x
7596                                                          fmulx.  */
7597                                                       return 443;
7598                                                     }
7599                                                 }
7600                                               else
7601                                                 {
7602                                                   if (((word >> 14) & 0x1) == 0)
7603                                                     {
7604                                                       /* 33222222222211111111110000000000
7605                                                          10987654321098765432109876543210
7606                                                          xxxxxxxxxx11110xxxxxx1xx0111101x
7607                                                          cmge.  */
7608                                                       return 448;
7609                                                     }
7610                                                   else
7611                                                     {
7612                                                       if (((word >> 23) & 0x1) == 0)
7613                                                         {
7614                                                           /* 33222222222211111111110000000000
7615                                                              10987654321098765432109876543210
7616                                                              xxxxxxxxxx11111xxxxxx1x00111101x
7617                                                              frecps.  */
7618                                                           return 445;
7619                                                         }
7620                                                       else
7621                                                         {
7622                                                           /* 33222222222211111111110000000000
7623                                                              10987654321098765432109876543210
7624                                                              xxxxxxxxxx11111xxxxxx1x10111101x
7625                                                              frsqrts.  */
7626                                                           return 446;
7627                                                         }
7628                                                     }
7629                                                 }
7630                                             }
7631                                         }
7632                                     }
7633                                   else
7634                                     {
7635                                       if (((word >> 12) & 0x1) == 0)
7636                                         {
7637                                           if (((word >> 13) & 0x1) == 0)
7638                                             {
7639                                               if (((word >> 14) & 0x1) == 0)
7640                                                 {
7641                                                   if (((word >> 15) & 0x1) == 0)
7642                                                     {
7643                                                       /* 33222222222211111111110000000000
7644                                                          10987654321098765432109876543210
7645                                                          xxxxxxxxxx110000xxxxx1xx011111xx
7646                                                          uqadd.  */
7647                                                       return 453;
7648                                                     }
7649                                                   else
7650                                                     {
7651                                                       /* 33222222222211111111110000000000
7652                                                          10987654321098765432109876543210
7653                                                          xxxxxxxxxx110001xxxxx1xx011111xx
7654                                                          cmeq.  */
7655                                                       return 468;
7656                                                     }
7657                                                 }
7658                                               else
7659                                                 {
7660                                                   /* 33222222222211111111110000000000
7661                                                      10987654321098765432109876543210
7662                                                      xxxxxxxxxx11001xxxxxx1xx011111xx
7663                                                      uqshl.  */
7664                                                   return 455;
7665                                                 }
7666                                             }
7667                                           else
7668                                             {
7669                                               if (((word >> 14) & 0x1) == 0)
7670                                                 {
7671                                                   /* 33222222222211111111110000000000
7672                                                      10987654321098765432109876543210
7673                                                      xxxxxxxxxx11010xxxxxx1xx011111xx
7674                                                      uqsub.  */
7675                                                   return 454;
7676                                                 }
7677                                               else
7678                                                 {
7679                                                   if (((word >> 23) & 0x1) == 0)
7680                                                     {
7681                                                       /* 33222222222211111111110000000000
7682                                                          10987654321098765432109876543210
7683                                                          xxxxxxxxxx11011xxxxxx1x0011111xx
7684                                                          facge.  */
7685                                                       return 459;
7686                                                     }
7687                                                   else
7688                                                     {
7689                                                       /* 33222222222211111111110000000000
7690                                                          10987654321098765432109876543210
7691                                                          xxxxxxxxxx11011xxxxxx1x1011111xx
7692                                                          facgt.  */
7693                                                       return 462;
7694                                                     }
7695                                                 }
7696                                             }
7697                                         }
7698                                       else
7699                                         {
7700                                           if (((word >> 13) & 0x1) == 0)
7701                                             {
7702                                               /* 33222222222211111111110000000000
7703                                                  10987654321098765432109876543210
7704                                                  xxxxxxxxxx1110xxxxxxx1xx011111xx
7705                                                  uqrshl.  */
7706                                               return 456;
7707                                             }
7708                                           else
7709                                             {
7710                                               /* 33222222222211111111110000000000
7711                                                  10987654321098765432109876543210
7712                                                  xxxxxxxxxx1111xxxxxxx1xx011111xx
7713                                                  cmhs.  */
7714                                               return 464;
7715                                             }
7716                                         }
7717                                     }
7718                                 }
7719                             }
7720                         }
7721                     }
7722                 }
7723               else
7724                 {
7725                   if (((word >> 15) & 0x1) == 0)
7726                     {
7727                       if (((word >> 28) & 0x1) == 0)
7728                         {
7729                           if (((word >> 10) & 0x1) == 0)
7730                             {
7731                               if (((word >> 12) & 0x1) == 0)
7732                                 {
7733                                   if (((word >> 13) & 0x1) == 0)
7734                                     {
7735                                       if (((word >> 14) & 0x1) == 0)
7736                                         {
7737                                           /* 33222222222211111111110000000000
7738                                              10987654321098765432109876543210
7739                                              xxxxxxxxxx0x0000xxxxxxxx11110xxx
7740                                              mla.  */
7741                                           return 110;
7742                                         }
7743                                       else
7744                                         {
7745                                           /* 33222222222211111111110000000000
7746                                              10987654321098765432109876543210
7747                                              xxxxxxxxxx0x0010xxxxxxxx11110xxx
7748                                              mls.  */
7749                                           return 113;
7750                                         }
7751                                     }
7752                                   else
7753                                     {
7754                                       if (((word >> 14) & 0x1) == 0)
7755                                         {
7756                                           if (((word >> 29) & 0x1) == 0)
7757                                             {
7758                                               if (((word >> 30) & 0x1) == 0)
7759                                                 {
7760                                                   /* 33222222222211111111110000000000
7761                                                      10987654321098765432109876543210
7762                                                      xxxxxxxxxx0x0100xxxxxxxx1111000x
7763                                                      smlal.  */
7764                                                   return 92;
7765                                                 }
7766                                               else
7767                                                 {
7768                                                   /* 33222222222211111111110000000000
7769                                                      10987654321098765432109876543210
7770                                                      xxxxxxxxxx0x0100xxxxxxxx1111001x
7771                                                      smlal2.  */
7772                                                   return 93;
7773                                                 }
7774                                             }
7775                                           else
7776                                             {
7777                                               if (((word >> 30) & 0x1) == 0)
7778                                                 {
7779                                                   /* 33222222222211111111110000000000
7780                                                      10987654321098765432109876543210
7781                                                      xxxxxxxxxx0x0100xxxxxxxx1111010x
7782                                                      umlal.  */
7783                                                   return 111;
7784                                                 }
7785                                               else
7786                                                 {
7787                                                   /* 33222222222211111111110000000000
7788                                                      10987654321098765432109876543210
7789                                                      xxxxxxxxxx0x0100xxxxxxxx1111011x
7790                                                      umlal2.  */
7791                                                   return 112;
7792                                                 }
7793                                             }
7794                                         }
7795                                       else
7796                                         {
7797                                           if (((word >> 29) & 0x1) == 0)
7798                                             {
7799                                               if (((word >> 30) & 0x1) == 0)
7800                                                 {
7801                                                   /* 33222222222211111111110000000000
7802                                                      10987654321098765432109876543210
7803                                                      xxxxxxxxxx0x0110xxxxxxxx1111000x
7804                                                      smlsl.  */
7805                                                   return 96;
7806                                                 }
7807                                               else
7808                                                 {
7809                                                   /* 33222222222211111111110000000000
7810                                                      10987654321098765432109876543210
7811                                                      xxxxxxxxxx0x0110xxxxxxxx1111001x
7812                                                      smlsl2.  */
7813                                                   return 97;
7814                                                 }
7815                                             }
7816                                           else
7817                                             {
7818                                               if (((word >> 30) & 0x1) == 0)
7819                                                 {
7820                                                   /* 33222222222211111111110000000000
7821                                                      10987654321098765432109876543210
7822                                                      xxxxxxxxxx0x0110xxxxxxxx1111010x
7823                                                      umlsl.  */
7824                                                   return 114;
7825                                                 }
7826                                               else
7827                                                 {
7828                                                   /* 33222222222211111111110000000000
7829                                                      10987654321098765432109876543210
7830                                                      xxxxxxxxxx0x0110xxxxxxxx1111011x
7831                                                      umlsl2.  */
7832                                                   return 115;
7833                                                 }
7834                                             }
7835                                         }
7836                                     }
7837                                 }
7838                               else
7839                                 {
7840                                   if (((word >> 13) & 0x1) == 0)
7841                                     {
7842                                       if (((word >> 14) & 0x1) == 0)
7843                                         {
7844                                           /* 33222222222211111111110000000000
7845                                              10987654321098765432109876543210
7846                                              xxxxxxxxxx0x1000xxxxxxxx11110xxx
7847                                              fmla.  */
7848                                           return 107;
7849                                         }
7850                                       else
7851                                         {
7852                                           /* 33222222222211111111110000000000
7853                                              10987654321098765432109876543210
7854                                              xxxxxxxxxx0x1010xxxxxxxx11110xxx
7855                                              fmls.  */
7856                                           return 108;
7857                                         }
7858                                     }
7859                                   else
7860                                     {
7861                                       if (((word >> 14) & 0x1) == 0)
7862                                         {
7863                                           if (((word >> 30) & 0x1) == 0)
7864                                             {
7865                                               /* 33222222222211111111110000000000
7866                                                  10987654321098765432109876543210
7867                                                  xxxxxxxxxx0x1100xxxxxxxx11110x0x
7868                                                  sqdmlal.  */
7869                                               return 94;
7870                                             }
7871                                           else
7872                                             {
7873                                               /* 33222222222211111111110000000000
7874                                                  10987654321098765432109876543210
7875                                                  xxxxxxxxxx0x1100xxxxxxxx11110x1x
7876                                                  sqdmlal2.  */
7877                                               return 95;
7878                                             }
7879                                         }
7880                                       else
7881                                         {
7882                                           if (((word >> 30) & 0x1) == 0)
7883                                             {
7884                                               /* 33222222222211111111110000000000
7885                                                  10987654321098765432109876543210
7886                                                  xxxxxxxxxx0x1110xxxxxxxx11110x0x
7887                                                  sqdmlsl.  */
7888                                               return 98;
7889                                             }
7890                                           else
7891                                             {
7892                                               /* 33222222222211111111110000000000
7893                                                  10987654321098765432109876543210
7894                                                  xxxxxxxxxx0x1110xxxxxxxx11110x1x
7895                                                  sqdmlsl2.  */
7896                                               return 99;
7897                                             }
7898                                         }
7899                                     }
7900                                 }
7901                             }
7902                           else
7903                             {
7904                               if (((word >> 12) & 0x1) == 0)
7905                                 {
7906                                   if (((word >> 29) & 0x1) == 0)
7907                                     {
7908                                       /* 33222222222211111111110000000000
7909                                          10987654321098765432109876543210
7910                                          xxxxxxxxxx1x0xx0xxxxxxxx111100xx
7911                                          movi.  */
7912                                       return 120;
7913                                     }
7914                                   else
7915                                     {
7916                                       /* 33222222222211111111110000000000
7917                                          10987654321098765432109876543210
7918                                          xxxxxxxxxx1x0xx0xxxxxxxx111101xx
7919                                          mvni.  */
7920                                       return 127;
7921                                     }
7922                                 }
7923                               else
7924                                 {
7925                                   if (((word >> 29) & 0x1) == 0)
7926                                     {
7927                                       /* 33222222222211111111110000000000
7928                                          10987654321098765432109876543210
7929                                          xxxxxxxxxx1x1xx0xxxxxxxx111100xx
7930                                          orr.  */
7931                                       return 121;
7932                                     }
7933                                   else
7934                                     {
7935                                       /* 33222222222211111111110000000000
7936                                          10987654321098765432109876543210
7937                                          xxxxxxxxxx1x1xx0xxxxxxxx111101xx
7938                                          bic.  */
7939                                       return 128;
7940                                     }
7941                                 }
7942                             }
7943                         }
7944                       else
7945                         {
7946                           if (((word >> 29) & 0x1) == 0)
7947                             {
7948                               if (((word >> 30) & 0x1) == 0)
7949                                 {
7950                                   if (((word >> 21) & 0x1) == 0)
7951                                     {
7952                                       /* 33222222222211111111110000000000
7953                                          10987654321098765432109876543210
7954                                          xxxxxxxxxxxxxxx0xxxxx0xx1111100x
7955                                          fmadd.  */
7956                                       return 643;
7957                                     }
7958                                   else
7959                                     {
7960                                       /* 33222222222211111111110000000000
7961                                          10987654321098765432109876543210
7962                                          xxxxxxxxxxxxxxx0xxxxx1xx1111100x
7963                                          fnmadd.  */
7964                                       return 645;
7965                                     }
7966                                 }
7967                               else
7968                                 {
7969                                   if (((word >> 10) & 0x1) == 0)
7970                                     {
7971                                       if (((word >> 13) & 0x1) == 0)
7972                                         {
7973                                           if (((word >> 14) & 0x1) == 0)
7974                                             {
7975                                               /* 33222222222211111111110000000000
7976                                                  10987654321098765432109876543210
7977                                                  xxxxxxxxxx0xx000xxxxxxxx1111101x
7978                                                  fmla.  */
7979                                               return 351;
7980                                             }
7981                                           else
7982                                             {
7983                                               /* 33222222222211111111110000000000
7984                                                  10987654321098765432109876543210
7985                                                  xxxxxxxxxx0xx010xxxxxxxx1111101x
7986                                                  fmls.  */
7987                                               return 352;
7988                                             }
7989                                         }
7990                                       else
7991                                         {
7992                                           if (((word >> 14) & 0x1) == 0)
7993                                             {
7994                                               /* 33222222222211111111110000000000
7995                                                  10987654321098765432109876543210
7996                                                  xxxxxxxxxx0xx100xxxxxxxx1111101x
7997                                                  sqdmlal.  */
7998                                               return 346;
7999                                             }
8000                                           else
8001                                             {
8002                                               /* 33222222222211111111110000000000
8003                                                  10987654321098765432109876543210
8004                                                  xxxxxxxxxx0xx110xxxxxxxx1111101x
8005                                                  sqdmlsl.  */
8006                                               return 347;
8007                                             }
8008                                         }
8009                                     }
8010                                   else
8011                                     {
8012                                       if (((word >> 12) & 0x1) == 0)
8013                                         {
8014                                           if (((word >> 13) & 0x1) == 0)
8015                                             {
8016                                               /* 33222222222211111111110000000000
8017                                                  10987654321098765432109876543210
8018                                                  xxxxxxxxxx1x00x0xxxxxxxx1111101x
8019                                                  sshr.  */
8020                                               return 469;
8021                                             }
8022                                           else
8023                                             {
8024                                               /* 33222222222211111111110000000000
8025                                                  10987654321098765432109876543210
8026                                                  xxxxxxxxxx1x01x0xxxxxxxx1111101x
8027                                                  srshr.  */
8028                                               return 471;
8029                                             }
8030                                         }
8031                                       else
8032                                         {
8033                                           if (((word >> 13) & 0x1) == 0)
8034                                             {
8035                                               if (((word >> 14) & 0x1) == 0)
8036                                                 {
8037                                                   /* 33222222222211111111110000000000
8038                                                      10987654321098765432109876543210
8039                                                      xxxxxxxxxx1x1000xxxxxxxx1111101x
8040                                                      ssra.  */
8041                                                   return 470;
8042                                                 }
8043                                               else
8044                                                 {
8045                                                   /* 33222222222211111111110000000000
8046                                                      10987654321098765432109876543210
8047                                                      xxxxxxxxxx1x1010xxxxxxxx1111101x
8048                                                      shl.  */
8049                                                   return 473;
8050                                                 }
8051                                             }
8052                                           else
8053                                             {
8054                                               if (((word >> 14) & 0x1) == 0)
8055                                                 {
8056                                                   /* 33222222222211111111110000000000
8057                                                      10987654321098765432109876543210
8058                                                      xxxxxxxxxx1x1100xxxxxxxx1111101x
8059                                                      srsra.  */
8060                                                   return 472;
8061                                                 }
8062                                               else
8063                                                 {
8064                                                   /* 33222222222211111111110000000000
8065                                                      10987654321098765432109876543210
8066                                                      xxxxxxxxxx1x1110xxxxxxxx1111101x
8067                                                      sqshl.  */
8068                                                   return 474;
8069                                                 }
8070                                             }
8071                                         }
8072                                     }
8073                                 }
8074                             }
8075                           else
8076                             {
8077                               if (((word >> 12) & 0x1) == 0)
8078                                 {
8079                                   if (((word >> 13) & 0x1) == 0)
8080                                     {
8081                                       if (((word >> 14) & 0x1) == 0)
8082                                         {
8083                                           /* 33222222222211111111110000000000
8084                                              10987654321098765432109876543210
8085                                              xxxxxxxxxxxx0000xxxxxxxx111111xx
8086                                              ushr.  */
8087                                           return 479;
8088                                         }
8089                                       else
8090                                         {
8091                                           /* 33222222222211111111110000000000
8092                                              10987654321098765432109876543210
8093                                              xxxxxxxxxxxx0010xxxxxxxx111111xx
8094                                              sri.  */
8095                                           return 483;
8096                                         }
8097                                     }
8098                                   else
8099                                     {
8100                                       if (((word >> 14) & 0x1) == 0)
8101                                         {
8102                                           /* 33222222222211111111110000000000
8103                                              10987654321098765432109876543210
8104                                              xxxxxxxxxxxx0100xxxxxxxx111111xx
8105                                              urshr.  */
8106                                           return 481;
8107                                         }
8108                                       else
8109                                         {
8110                                           /* 33222222222211111111110000000000
8111                                              10987654321098765432109876543210
8112                                              xxxxxxxxxxxx0110xxxxxxxx111111xx
8113                                              sqshlu.  */
8114                                           return 485;
8115                                         }
8116                                     }
8117                                 }
8118                               else
8119                                 {
8120                                   if (((word >> 13) & 0x1) == 0)
8121                                     {
8122                                       if (((word >> 14) & 0x1) == 0)
8123                                         {
8124                                           /* 33222222222211111111110000000000
8125                                              10987654321098765432109876543210
8126                                              xxxxxxxxxxxx1000xxxxxxxx111111xx
8127                                              usra.  */
8128                                           return 480;
8129                                         }
8130                                       else
8131                                         {
8132                                           /* 33222222222211111111110000000000
8133                                              10987654321098765432109876543210
8134                                              xxxxxxxxxxxx1010xxxxxxxx111111xx
8135                                              sli.  */
8136                                           return 484;
8137                                         }
8138                                     }
8139                                   else
8140                                     {
8141                                       if (((word >> 14) & 0x1) == 0)
8142                                         {
8143                                           /* 33222222222211111111110000000000
8144                                              10987654321098765432109876543210
8145                                              xxxxxxxxxxxx1100xxxxxxxx111111xx
8146                                              ursra.  */
8147                                           return 482;
8148                                         }
8149                                       else
8150                                         {
8151                                           /* 33222222222211111111110000000000
8152                                              10987654321098765432109876543210
8153                                              xxxxxxxxxxxx1110xxxxxxxx111111xx
8154                                              uqshl.  */
8155                                           return 486;
8156                                         }
8157                                     }
8158                                 }
8159                             }
8160                         }
8161                     }
8162                   else
8163                     {
8164                       if (((word >> 28) & 0x1) == 0)
8165                         {
8166                           if (((word >> 10) & 0x1) == 0)
8167                             {
8168                               if (((word >> 12) & 0x1) == 0)
8169                                 {
8170                                   if (((word >> 13) & 0x1) == 0)
8171                                     {
8172                                       if (((word >> 14) & 0x1) == 0)
8173                                         {
8174                                           /* 33222222222211111111110000000000
8175                                              10987654321098765432109876543210
8176                                              xxxxxxxxxx0x0001xxxxxxxx11110xxx
8177                                              mul.  */
8178                                           return 100;
8179                                         }
8180                                       else
8181                                         {
8182                                           /* 33222222222211111111110000000000
8183                                              10987654321098765432109876543210
8184                                              xxxxxxxxxx0x0011xxxxxxxx11110xxx
8185                                              sqdmulh.  */
8186                                           return 105;
8187                                         }
8188                                     }
8189                                   else
8190                                     {
8191                                       if (((word >> 29) & 0x1) == 0)
8192                                         {
8193                                           if (((word >> 30) & 0x1) == 0)
8194                                             {
8195                                               /* 33222222222211111111110000000000
8196                                                  10987654321098765432109876543210
8197                                                  xxxxxxxxxx0x01x1xxxxxxxx1111000x
8198                                                  smull.  */
8199                                               return 101;
8200                                             }
8201                                           else
8202                                             {
8203                                               /* 33222222222211111111110000000000
8204                                                  10987654321098765432109876543210
8205                                                  xxxxxxxxxx0x01x1xxxxxxxx1111001x
8206                                                  smull2.  */
8207                                               return 102;
8208                                             }
8209                                         }
8210                                       else
8211                                         {
8212                                           if (((word >> 30) & 0x1) == 0)
8213                                             {
8214                                               /* 33222222222211111111110000000000
8215                                                  10987654321098765432109876543210
8216                                                  xxxxxxxxxx0x01x1xxxxxxxx1111010x
8217                                                  umull.  */
8218                                               return 116;
8219                                             }
8220                                           else
8221                                             {
8222                                               /* 33222222222211111111110000000000
8223                                                  10987654321098765432109876543210
8224                                                  xxxxxxxxxx0x01x1xxxxxxxx1111011x
8225                                                  umull2.  */
8226                                               return 117;
8227                                             }
8228                                         }
8229                                     }
8230                                 }
8231                               else
8232                                 {
8233                                   if (((word >> 13) & 0x1) == 0)
8234                                     {
8235                                       if (((word >> 14) & 0x1) == 0)
8236                                         {
8237                                           if (((word >> 29) & 0x1) == 0)
8238                                             {
8239                                               /* 33222222222211111111110000000000
8240                                                  10987654321098765432109876543210
8241                                                  xxxxxxxxxx0x1001xxxxxxxx111100xx
8242                                                  fmul.  */
8243                                               return 109;
8244                                             }
8245                                           else
8246                                             {
8247                                               /* 33222222222211111111110000000000
8248                                                  10987654321098765432109876543210
8249                                                  xxxxxxxxxx0x1001xxxxxxxx111101xx
8250                                                  fmulx.  */
8251                                               return 118;
8252                                             }
8253                                         }
8254                                       else
8255                                         {
8256                                           /* 33222222222211111111110000000000
8257                                              10987654321098765432109876543210
8258                                              xxxxxxxxxx0x1011xxxxxxxx11110xxx
8259                                              sqrdmulh.  */
8260                                           return 106;
8261                                         }
8262                                     }
8263                                   else
8264                                     {
8265                                       if (((word >> 30) & 0x1) == 0)
8266                                         {
8267                                           /* 33222222222211111111110000000000
8268                                              10987654321098765432109876543210
8269                                              xxxxxxxxxx0x11x1xxxxxxxx11110x0x
8270                                              sqdmull.  */
8271                                           return 103;
8272                                         }
8273                                       else
8274                                         {
8275                                           /* 33222222222211111111110000000000
8276                                              10987654321098765432109876543210
8277                                              xxxxxxxxxx0x11x1xxxxxxxx11110x1x
8278                                              sqdmull2.  */
8279                                           return 104;
8280                                         }
8281                                     }
8282                                 }
8283                             }
8284                           else
8285                             {
8286                               if (((word >> 11) & 0x1) == 0)
8287                                 {
8288                                   if (((word >> 14) & 0x1) == 0)
8289                                     {
8290                                       if (((word >> 12) & 0x1) == 0)
8291                                         {
8292                                           if (((word >> 29) & 0x1) == 0)
8293                                             {
8294                                               /* 33222222222211111111110000000000
8295                                                  10987654321098765432109876543210
8296                                                  xxxxxxxxxx100x01xxxxxxxx111100xx
8297                                                  movi.  */
8298                                               return 122;
8299                                             }
8300                                           else
8301                                             {
8302                                               /* 33222222222211111111110000000000
8303                                                  10987654321098765432109876543210
8304                                                  xxxxxxxxxx100x01xxxxxxxx111101xx
8305                                                  mvni.  */
8306                                               return 129;
8307                                             }
8308                                         }
8309                                       else
8310                                         {
8311                                           if (((word >> 29) & 0x1) == 0)
8312                                             {
8313                                               /* 33222222222211111111110000000000
8314                                                  10987654321098765432109876543210
8315                                                  xxxxxxxxxx101x01xxxxxxxx111100xx
8316                                                  orr.  */
8317                                               return 123;
8318                                             }
8319                                           else
8320                                             {
8321                                               /* 33222222222211111111110000000000
8322                                                  10987654321098765432109876543210
8323                                                  xxxxxxxxxx101x01xxxxxxxx111101xx
8324                                                  bic.  */
8325                                               return 130;
8326                                             }
8327                                         }
8328                                     }
8329                                   else
8330                                     {
8331                                       if (((word >> 13) & 0x1) == 0)
8332                                         {
8333                                           if (((word >> 29) & 0x1) == 0)
8334                                             {
8335                                               /* 33222222222211111111110000000000
8336                                                  10987654321098765432109876543210
8337                                                  xxxxxxxxxx10x011xxxxxxxx111100xx
8338                                                  movi.  */
8339                                               return 124;
8340                                             }
8341                                           else
8342                                             {
8343                                               /* 33222222222211111111110000000000
8344                                                  10987654321098765432109876543210
8345                                                  xxxxxxxxxx10x011xxxxxxxx111101xx
8346                                                  mvni.  */
8347                                               return 131;
8348                                             }
8349                                         }
8350                                       else
8351                                         {
8352                                           if (((word >> 12) & 0x1) == 0)
8353                                             {
8354                                               if (((word >> 29) & 0x1) == 0)
8355                                                 {
8356                                                   /* 33222222222211111111110000000000
8357                                                      10987654321098765432109876543210
8358                                                      xxxxxxxxxx100111xxxxxxxx111100xx
8359                                                      movi.  */
8360                                                   return 125;
8361                                                 }
8362                                               else
8363                                                 {
8364                                                   /* 33222222222211111111110000000000
8365                                                      10987654321098765432109876543210
8366                                                      xxxxxxxxxx100111xxxxxxxx111101xx
8367                                                      movi.  */
8368                                                   return 132;
8369                                                 }
8370                                             }
8371                                           else
8372                                             {
8373                                               if (((word >> 29) & 0x1) == 0)
8374                                                 {
8375                                                   /* 33222222222211111111110000000000
8376                                                      10987654321098765432109876543210
8377                                                      xxxxxxxxxx101111xxxxxxxx111100xx
8378                                                      fmov.  */
8379                                                   return 126;
8380                                                 }
8381                                               else
8382                                                 {
8383                                                   /* 33222222222211111111110000000000
8384                                                      10987654321098765432109876543210
8385                                                      xxxxxxxxxx101111xxxxxxxx111101xx
8386                                                      fmov.  */
8387                                                   return 134;
8388                                                 }
8389                                             }
8390                                         }
8391                                     }
8392                                 }
8393                               else
8394                                 {
8395                                   if (((word >> 12) & 0x1) == 0)
8396                                     {
8397                                       if (((word >> 29) & 0x1) == 0)
8398                                         {
8399                                           if (((word >> 30) & 0x1) == 0)
8400                                             {
8401                                               /* 33222222222211111111110000000000
8402                                                  10987654321098765432109876543210
8403                                                  xxxxxxxxxx110xx1xxxxxxxx1111000x
8404                                                  rshrn.  */
8405                                               return 307;
8406                                             }
8407                                           else
8408                                             {
8409                                               /* 33222222222211111111110000000000
8410                                                  10987654321098765432109876543210
8411                                                  xxxxxxxxxx110xx1xxxxxxxx1111001x
8412                                                  rshrn2.  */
8413                                               return 308;
8414                                             }
8415                                         }
8416                                       else
8417                                         {
8418                                           if (((word >> 30) & 0x1) == 0)
8419                                             {
8420                                               /* 33222222222211111111110000000000
8421                                                  10987654321098765432109876543210
8422                                                  xxxxxxxxxx110xx1xxxxxxxx1111010x
8423                                                  sqrshrun.  */
8424                                               return 329;
8425                                             }
8426                                           else
8427                                             {
8428                                               /* 33222222222211111111110000000000
8429                                                  10987654321098765432109876543210
8430                                                  xxxxxxxxxx110xx1xxxxxxxx1111011x
8431                                                  sqrshrun2.  */
8432                                               return 330;
8433                                             }
8434                                         }
8435                                     }
8436                                   else
8437                                     {
8438                                       if (((word >> 13) & 0x1) == 0)
8439                                         {
8440                                           if (((word >> 29) & 0x1) == 0)
8441                                             {
8442                                               if (((word >> 30) & 0x1) == 0)
8443                                                 {
8444                                                   /* 33222222222211111111110000000000
8445                                                      10987654321098765432109876543210
8446                                                      xxxxxxxxxx1110x1xxxxxxxx1111000x
8447                                                      sqrshrn.  */
8448                                                   return 311;
8449                                                 }
8450                                               else
8451                                                 {
8452                                                   /* 33222222222211111111110000000000
8453                                                      10987654321098765432109876543210
8454                                                      xxxxxxxxxx1110x1xxxxxxxx1111001x
8455                                                      sqrshrn2.  */
8456                                                   return 312;
8457                                                 }
8458                                             }
8459                                           else
8460                                             {
8461                                               if (((word >> 30) & 0x1) == 0)
8462                                                 {
8463                                                   /* 33222222222211111111110000000000
8464                                                      10987654321098765432109876543210
8465                                                      xxxxxxxxxx1110x1xxxxxxxx1111010x
8466                                                      uqrshrn.  */
8467                                                   return 333;
8468                                                 }
8469                                               else
8470                                                 {
8471                                                   /* 33222222222211111111110000000000
8472                                                      10987654321098765432109876543210
8473                                                      xxxxxxxxxx1110x1xxxxxxxx1111011x
8474                                                      uqrshrn2.  */
8475                                                   return 334;
8476                                                 }
8477                                             }
8478                                         }
8479                                       else
8480                                         {
8481                                           if (((word >> 29) & 0x1) == 0)
8482                                             {
8483                                               /* 33222222222211111111110000000000
8484                                                  10987654321098765432109876543210
8485                                                  xxxxxxxxxx1111x1xxxxxxxx111100xx
8486                                                  fcvtzs.  */
8487                                               return 318;
8488                                             }
8489                                           else
8490                                             {
8491                                               /* 33222222222211111111110000000000
8492                                                  10987654321098765432109876543210
8493                                                  xxxxxxxxxx1111x1xxxxxxxx111101xx
8494                                                  fcvtzu.  */
8495                                               return 340;
8496                                             }
8497                                         }
8498                                     }
8499                                 }
8500                             }
8501                         }
8502                       else
8503                         {
8504                           if (((word >> 29) & 0x1) == 0)
8505                             {
8506                               if (((word >> 30) & 0x1) == 0)
8507                                 {
8508                                   if (((word >> 21) & 0x1) == 0)
8509                                     {
8510                                       /* 33222222222211111111110000000000
8511                                          10987654321098765432109876543210
8512                                          xxxxxxxxxxxxxxx1xxxxx0xx1111100x
8513                                          fmsub.  */
8514                                       return 644;
8515                                     }
8516                                   else
8517                                     {
8518                                       /* 33222222222211111111110000000000
8519                                          10987654321098765432109876543210
8520                                          xxxxxxxxxxxxxxx1xxxxx1xx1111100x
8521                                          fnmsub.  */
8522                                       return 646;
8523                                     }
8524                                 }
8525                               else
8526                                 {
8527                                   if (((word >> 10) & 0x1) == 0)
8528                                     {
8529                                       if (((word >> 12) & 0x1) == 0)
8530                                         {
8531                                           /* 33222222222211111111110000000000
8532                                              10987654321098765432109876543210
8533                                              xxxxxxxxxx0x0xx1xxxxxxxx1111101x
8534                                              sqdmulh.  */
8535                                           return 349;
8536                                         }
8537                                       else
8538                                         {
8539                                           if (((word >> 13) & 0x1) == 0)
8540                                             {
8541                                               if (((word >> 14) & 0x1) == 0)
8542                                                 {
8543                                                   /* 33222222222211111111110000000000
8544                                                      10987654321098765432109876543210
8545                                                      xxxxxxxxxx0x1001xxxxxxxx1111101x
8546                                                      fmul.  */
8547                                                   return 353;
8548                                                 }
8549                                               else
8550                                                 {
8551                                                   /* 33222222222211111111110000000000
8552                                                      10987654321098765432109876543210
8553                                                      xxxxxxxxxx0x1011xxxxxxxx1111101x
8554                                                      sqrdmulh.  */
8555                                                   return 350;
8556                                                 }
8557                                             }
8558                                           else
8559                                             {
8560                                               /* 33222222222211111111110000000000
8561                                                  10987654321098765432109876543210
8562                                                  xxxxxxxxxx0x11x1xxxxxxxx1111101x
8563                                                  sqdmull.  */
8564                                               return 348;
8565                                             }
8566                                         }
8567                                     }
8568                                   else
8569                                     {
8570                                       if (((word >> 11) & 0x1) == 0)
8571                                         {
8572                                           if (((word >> 12) & 0x1) == 0)
8573                                             {
8574                                               /* 33222222222211111111110000000000
8575                                                  10987654321098765432109876543210
8576                                                  xxxxxxxxxx100xx1xxxxxxxx1111101x
8577                                                  scvtf.  */
8578                                               return 477;
8579                                             }
8580                                           else
8581                                             {
8582                                               /* 33222222222211111111110000000000
8583                                                  10987654321098765432109876543210
8584                                                  xxxxxxxxxx101xx1xxxxxxxx1111101x
8585                                                  sqshrn.  */
8586                                               return 475;
8587                                             }
8588                                         }
8589                                       else
8590                                         {
8591                                           if (((word >> 13) & 0x1) == 0)
8592                                             {
8593                                               /* 33222222222211111111110000000000
8594                                                  10987654321098765432109876543210
8595                                                  xxxxxxxxxx11x0x1xxxxxxxx1111101x
8596                                                  sqrshrn.  */
8597                                               return 476;
8598                                             }
8599                                           else
8600                                             {
8601                                               /* 33222222222211111111110000000000
8602                                                  10987654321098765432109876543210
8603                                                  xxxxxxxxxx11x1x1xxxxxxxx1111101x
8604                                                  fcvtzs.  */
8605                                               return 478;
8606                                             }
8607                                         }
8608                                     }
8609                                 }
8610                             }
8611                           else
8612                             {
8613                               if (((word >> 10) & 0x1) == 0)
8614                                 {
8615                                   /* 33222222222211111111110000000000
8616                                      10987654321098765432109876543210
8617                                      xxxxxxxxxx0xxxx1xxxxxxxx111111xx
8618                                      fmulx.  */
8619                                   return 354;
8620                                 }
8621                               else
8622                                 {
8623                                   if (((word >> 11) & 0x1) == 0)
8624                                     {
8625                                       if (((word >> 12) & 0x1) == 0)
8626                                         {
8627                                           if (((word >> 13) & 0x1) == 0)
8628                                             {
8629                                               /* 33222222222211111111110000000000
8630                                                  10987654321098765432109876543210
8631                                                  xxxxxxxxxx1000x1xxxxxxxx111111xx
8632                                                  sqshrun.  */
8633                                               return 487;
8634                                             }
8635                                           else
8636                                             {
8637                                               /* 33222222222211111111110000000000
8638                                                  10987654321098765432109876543210
8639                                                  xxxxxxxxxx1001x1xxxxxxxx111111xx
8640                                                  ucvtf.  */
8641                                               return 491;
8642                                             }
8643                                         }
8644                                       else
8645                                         {
8646                                           /* 33222222222211111111110000000000
8647                                              10987654321098765432109876543210
8648                                              xxxxxxxxxx101xx1xxxxxxxx111111xx
8649                                              uqshrn.  */
8650                                           return 489;
8651                                         }
8652                                     }
8653                                   else
8654                                     {
8655                                       if (((word >> 12) & 0x1) == 0)
8656                                         {
8657                                           /* 33222222222211111111110000000000
8658                                              10987654321098765432109876543210
8659                                              xxxxxxxxxx110xx1xxxxxxxx111111xx
8660                                              sqrshrun.  */
8661                                           return 488;
8662                                         }
8663                                       else
8664                                         {
8665                                           if (((word >> 13) & 0x1) == 0)
8666                                             {
8667                                               /* 33222222222211111111110000000000
8668                                                  10987654321098765432109876543210
8669                                                  xxxxxxxxxx1110x1xxxxxxxx111111xx
8670                                                  uqrshrn.  */
8671                                               return 490;
8672                                             }
8673                                           else
8674                                             {
8675                                               /* 33222222222211111111110000000000
8676                                                  10987654321098765432109876543210
8677                                                  xxxxxxxxxx1111x1xxxxxxxx111111xx
8678                                                  fcvtzu.  */
8679                                               return 492;
8680                                             }
8681                                         }
8682                                     }
8683                                 }
8684                             }
8685                         }
8686                     }
8687                 }
8688             }
8689         }
8690     }
8691 }
8692
8693 /* Lookup opcode WORD in the opcode table.  N.B. all alias
8694    opcodes are ignored here.  */
8695
8696 const aarch64_opcode *
8697 aarch64_opcode_lookup (uint32_t word)
8698 {
8699   return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);
8700 }
8701
8702 const aarch64_opcode *
8703 aarch64_find_next_opcode (const aarch64_opcode *opcode)
8704 {
8705   /* Use the index as the key to locate the next opcode.  */
8706   int key = opcode - aarch64_opcode_table;
8707   int value;
8708   switch (key)
8709     {
8710     case 739: value = 743; break;       /* stnp --> stp.  */
8711     case 743: return NULL;              /* stp --> NULL.  */
8712     case 740: value = 744; break;       /* ldnp --> ldp.  */
8713     case 744: return NULL;              /* ldp --> NULL.  */
8714     case 955: value = 956; break;       /* msr --> hint.  */
8715     case 956: value = 963; break;       /* hint --> clrex.  */
8716     case 963: value = 964; break;       /* clrex --> dsb.  */
8717     case 964: value = 965; break;       /* dsb --> dmb.  */
8718     case 965: value = 966; break;       /* dmb --> isb.  */
8719     case 966: value = 967; break;       /* isb --> sys.  */
8720     case 967: value = 972; break;       /* sys --> msr.  */
8721     case 972: return NULL;              /* msr --> NULL.  */
8722     case 973: value = 974; break;       /* sysl --> mrs.  */
8723     case 974: return NULL;              /* mrs --> NULL.  */
8724     case 355: value = 356; break;       /* st4 --> st1.  */
8725     case 356: value = 357; break;       /* st1 --> st2.  */
8726     case 357: value = 358; break;       /* st2 --> st3.  */
8727     case 358: return NULL;              /* st3 --> NULL.  */
8728     case 363: value = 364; break;       /* st4 --> st1.  */
8729     case 364: value = 365; break;       /* st1 --> st2.  */
8730     case 365: value = 366; break;       /* st2 --> st3.  */
8731     case 366: return NULL;              /* st3 --> NULL.  */
8732     case 359: value = 360; break;       /* ld4 --> ld1.  */
8733     case 360: value = 361; break;       /* ld1 --> ld2.  */
8734     case 361: value = 362; break;       /* ld2 --> ld3.  */
8735     case 362: return NULL;              /* ld3 --> NULL.  */
8736     case 375: value = 377; break;       /* ld1 --> ld1r.  */
8737     case 377: return NULL;              /* ld1r --> NULL.  */
8738     case 379: value = 381; break;       /* ld2 --> ld2r.  */
8739     case 381: return NULL;              /* ld2r --> NULL.  */
8740     case 376: value = 378; break;       /* ld3 --> ld3r.  */
8741     case 378: return NULL;              /* ld3r --> NULL.  */
8742     case 380: value = 382; break;       /* ld4 --> ld4r.  */
8743     case 382: return NULL;              /* ld4r --> NULL.  */
8744     case 367: value = 368; break;       /* ld4 --> ld1.  */
8745     case 368: value = 369; break;       /* ld1 --> ld2.  */
8746     case 369: value = 370; break;       /* ld2 --> ld3.  */
8747     case 370: return NULL;              /* ld3 --> NULL.  */
8748     case 387: value = 389; break;       /* ld1 --> ld1r.  */
8749     case 389: return NULL;              /* ld1r --> NULL.  */
8750     case 388: value = 390; break;       /* ld3 --> ld3r.  */
8751     case 390: return NULL;              /* ld3r --> NULL.  */
8752     case 391: value = 393; break;       /* ld2 --> ld2r.  */
8753     case 393: return NULL;              /* ld2r --> NULL.  */
8754     case 392: value = 394; break;       /* ld4 --> ld4r.  */
8755     case 394: return NULL;              /* ld4r --> NULL.  */
8756     case 120: value = 299; break;       /* movi --> sshr.  */
8757     case 299: value = 301; break;       /* sshr --> srshr.  */
8758     case 301: return NULL;              /* srshr --> NULL.  */
8759     case 127: value = 319; break;       /* mvni --> ushr.  */
8760     case 319: value = 321; break;       /* ushr --> urshr.  */
8761     case 321: value = 323; break;       /* urshr --> sri.  */
8762     case 323: value = 325; break;       /* sri --> sqshlu.  */
8763     case 325: return NULL;              /* sqshlu --> NULL.  */
8764     case 121: value = 300; break;       /* orr --> ssra.  */
8765     case 300: value = 302; break;       /* ssra --> srsra.  */
8766     case 302: value = 303; break;       /* srsra --> shl.  */
8767     case 303: value = 304; break;       /* shl --> sqshl.  */
8768     case 304: return NULL;              /* sqshl --> NULL.  */
8769     case 128: value = 320; break;       /* bic --> usra.  */
8770     case 320: value = 322; break;       /* usra --> ursra.  */
8771     case 322: value = 324; break;       /* ursra --> sli.  */
8772     case 324: value = 326; break;       /* sli --> uqshl.  */
8773     case 326: return NULL;              /* uqshl --> NULL.  */
8774     case 122: value = 305; break;       /* movi --> shrn.  */
8775     case 305: value = 306; break;       /* shrn --> shrn2.  */
8776     case 306: value = 313; break;       /* shrn2 --> sshll.  */
8777     case 313: value = 315; break;       /* sshll --> sshll2.  */
8778     case 315: return NULL;              /* sshll2 --> NULL.  */
8779     case 129: value = 327; break;       /* mvni --> sqshrun.  */
8780     case 327: value = 328; break;       /* sqshrun --> sqshrun2.  */
8781     case 328: value = 335; break;       /* sqshrun2 --> ushll.  */
8782     case 335: value = 337; break;       /* ushll --> ushll2.  */
8783     case 337: return NULL;              /* ushll2 --> NULL.  */
8784     case 123: value = 309; break;       /* orr --> sqshrn.  */
8785     case 309: value = 310; break;       /* sqshrn --> sqshrn2.  */
8786     case 310: return NULL;              /* sqshrn2 --> NULL.  */
8787     case 130: value = 331; break;       /* bic --> uqshrn.  */
8788     case 331: value = 332; break;       /* uqshrn --> uqshrn2.  */
8789     case 332: return NULL;              /* uqshrn2 --> NULL.  */
8790     case 125: value = 317; break;       /* movi --> scvtf.  */
8791     case 317: return NULL;              /* scvtf --> NULL.  */
8792     case 132: value = 133; break;       /* movi --> movi.  */
8793     case 133: value = 339; break;       /* movi --> ucvtf.  */
8794     case 339: return NULL;              /* ucvtf --> NULL.  */
8795     default: return NULL;
8796     }
8797
8798   return aarch64_opcode_table + value;
8799 }
8800
8801 const aarch64_opcode *
8802 aarch64_find_alias_opcode (const aarch64_opcode *opcode)
8803 {
8804   /* Use the index as the key to locate the alias opcode.  */
8805   int key = opcode - aarch64_opcode_table;
8806   int value;
8807   switch (key)
8808     {
8809     case 2: value = 3; break;   /* sbc --> ngc.  */
8810     case 4: value = 5; break;   /* sbcs --> ngcs.  */
8811     case 7: value = 8; break;   /* adds --> cmn.  */
8812     case 10: value = 11; break; /* subs --> cmp.  */
8813     case 12: value = 13; break; /* add --> mov.  */
8814     case 14: value = 15; break; /* adds --> cmn.  */
8815     case 17: value = 18; break; /* subs --> cmp.  */
8816     case 20: value = 21; break; /* adds --> cmn.  */
8817     case 22: value = 23; break; /* sub --> neg.  */
8818     case 24: value = 26; break; /* subs --> negs.  */
8819     case 138: value = 139; break;       /* umov --> mov.  */
8820     case 140: value = 141; break;       /* ins --> mov.  */
8821     case 142: value = 143; break;       /* ins --> mov.  */
8822     case 203: value = 204; break;       /* not --> mvn.  */
8823     case 258: value = 259; break;       /* orr --> mov.  */
8824     case 313: value = 314; break;       /* sshll --> sxtl.  */
8825     case 315: value = 316; break;       /* sshll2 --> sxtl2.  */
8826     case 335: value = 336; break;       /* ushll --> uxtl.  */
8827     case 337: value = 338; break;       /* ushll2 --> uxtl2.  */
8828     case 430: value = 431; break;       /* dup --> mov.  */
8829     case 493: value = 498; break;       /* sbfm --> sxtw.  */
8830     case 500: value = 502; break;       /* bfm --> bfxil.  */
8831     case 503: value = 507; break;       /* ubfm --> uxth.  */
8832     case 525: value = 527; break;       /* csinc --> cset.  */
8833     case 528: value = 530; break;       /* csinv --> csetm.  */
8834     case 531: value = 532; break;       /* csneg --> cneg.  */
8835     case 556: value = 557; break;       /* lslv --> lsl.  */
8836     case 558: value = 559; break;       /* lsrv --> lsr.  */
8837     case 560: value = 561; break;       /* asrv --> asr.  */
8838     case 562: value = 563; break;       /* rorv --> ror.  */
8839     case 572: value = 573; break;       /* madd --> mul.  */
8840     case 574: value = 575; break;       /* msub --> mneg.  */
8841     case 576: value = 577; break;       /* smaddl --> smull.  */
8842     case 578: value = 579; break;       /* smsubl --> smnegl.  */
8843     case 581: value = 582; break;       /* umaddl --> umull.  */
8844     case 583: value = 584; break;       /* umsubl --> umnegl.  */
8845     case 594: value = 595; break;       /* extr --> ror.  */
8846     case 693: value = 695; break;       /* sturb --> strb.  */
8847     case 694: value = 696; break;       /* ldurb --> ldrb.  */
8848     case 697: value = 698; break;       /* ldursb --> ldrsb.  */
8849     case 699: value = 701; break;       /* stur --> str.  */
8850     case 700: value = 702; break;       /* ldur --> ldr.  */
8851     case 703: value = 705; break;       /* sturh --> strh.  */
8852     case 704: value = 706; break;       /* ldurh --> ldrh.  */
8853     case 707: value = 708; break;       /* ldursh --> ldrsh.  */
8854     case 709: value = 711; break;       /* stur --> str.  */
8855     case 710: value = 712; break;       /* ldur --> ldr.  */
8856     case 713: value = 714; break;       /* ldursw --> ldrsw.  */
8857     case 715: value = 716; break;       /* prfum --> prfm.  */
8858     case 757: value = 758; break;       /* and --> bic.  */
8859     case 759: value = 760; break;       /* orr --> mov.  */
8860     case 762: value = 763; break;       /* ands --> tst.  */
8861     case 766: value = 768; break;       /* orr --> uxtw.  */
8862     case 769: value = 770; break;       /* orn --> mvn.  */
8863     case 773: value = 774; break;       /* ands --> tst.  */
8864     case 804: value = 900; break;       /* ldaddb --> staddb.  */
8865     case 805: value = 901; break;       /* ldaddh --> staddh.  */
8866     case 806: value = 902; break;       /* ldadd --> stadd.  */
8867     case 808: value = 903; break;       /* ldaddlb --> staddlb.  */
8868     case 811: value = 904; break;       /* ldaddlh --> staddlh.  */
8869     case 814: value = 905; break;       /* ldaddl --> staddl.  */
8870     case 816: value = 906; break;       /* ldclrb --> stclrb.  */
8871     case 817: value = 907; break;       /* ldclrh --> stclrh.  */
8872     case 818: value = 908; break;       /* ldclr --> stclr.  */
8873     case 820: value = 909; break;       /* ldclrlb --> stclrlb.  */
8874     case 823: value = 910; break;       /* ldclrlh --> stclrlh.  */
8875     case 826: value = 911; break;       /* ldclrl --> stclrl.  */
8876     case 828: value = 912; break;       /* ldeorb --> steorb.  */
8877     case 829: value = 913; break;       /* ldeorh --> steorh.  */
8878     case 830: value = 914; break;       /* ldeor --> steor.  */
8879     case 832: value = 915; break;       /* ldeorlb --> steorlb.  */
8880     case 835: value = 916; break;       /* ldeorlh --> steorlh.  */
8881     case 838: value = 917; break;       /* ldeorl --> steorl.  */
8882     case 840: value = 918; break;       /* ldsetb --> stsetb.  */
8883     case 841: value = 919; break;       /* ldseth --> stseth.  */
8884     case 842: value = 920; break;       /* ldset --> stset.  */
8885     case 844: value = 921; break;       /* ldsetlb --> stsetlb.  */
8886     case 847: value = 922; break;       /* ldsetlh --> stsetlh.  */
8887     case 850: value = 923; break;       /* ldsetl --> stsetl.  */
8888     case 852: value = 924; break;       /* ldsmaxb --> stsmaxb.  */
8889     case 853: value = 925; break;       /* ldsmaxh --> stsmaxh.  */
8890     case 854: value = 926; break;       /* ldsmax --> stsmax.  */
8891     case 856: value = 927; break;       /* ldsmaxlb --> stsmaxlb.  */
8892     case 859: value = 928; break;       /* ldsmaxlh --> stsmaxlh.  */
8893     case 862: value = 929; break;       /* ldsmaxl --> stsmaxl.  */
8894     case 864: value = 930; break;       /* ldsminb --> stsminb.  */
8895     case 865: value = 931; break;       /* ldsminh --> stsminh.  */
8896     case 866: value = 932; break;       /* ldsmin --> stsmin.  */
8897     case 868: value = 933; break;       /* ldsminlb --> stsminlb.  */
8898     case 871: value = 934; break;       /* ldsminlh --> stsminlh.  */
8899     case 874: value = 935; break;       /* ldsminl --> stsminl.  */
8900     case 876: value = 936; break;       /* ldumaxb --> stumaxb.  */
8901     case 877: value = 937; break;       /* ldumaxh --> stumaxh.  */
8902     case 878: value = 938; break;       /* ldumax --> stumax.  */
8903     case 880: value = 939; break;       /* ldumaxlb --> stumaxlb.  */
8904     case 883: value = 940; break;       /* ldumaxlh --> stumaxlh.  */
8905     case 886: value = 941; break;       /* ldumaxl --> stumaxl.  */
8906     case 888: value = 942; break;       /* lduminb --> stuminb.  */
8907     case 889: value = 943; break;       /* lduminh --> stuminh.  */
8908     case 890: value = 944; break;       /* ldumin --> stumin.  */
8909     case 892: value = 945; break;       /* lduminlb --> stuminlb.  */
8910     case 895: value = 946; break;       /* lduminlh --> stuminlh.  */
8911     case 898: value = 947; break;       /* lduminl --> stuminl.  */
8912     case 948: value = 949; break;       /* movn --> mov.  */
8913     case 950: value = 951; break;       /* movz --> mov.  */
8914     case 956: value = 962; break;       /* hint --> sevl.  */
8915     case 967: value = 971; break;       /* sys --> tlbi.  */
8916     default: return NULL;
8917     }
8918
8919   return aarch64_opcode_table + value;
8920 }
8921
8922 const aarch64_opcode *
8923 aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)
8924 {
8925   /* Use the index as the key to locate the next opcode.  */
8926   int key = opcode - aarch64_opcode_table;
8927   int value;
8928   switch (key)
8929     {
8930     case 26: value = 25; break; /* negs --> cmp.  */
8931     case 498: value = 497; break;       /* sxtw --> sxth.  */
8932     case 497: value = 496; break;       /* sxth --> sxtb.  */
8933     case 496: value = 499; break;       /* sxtb --> asr.  */
8934     case 499: value = 495; break;       /* asr --> sbfx.  */
8935     case 495: value = 494; break;       /* sbfx --> sbfiz.  */
8936     case 502: value = 501; break;       /* bfxil --> bfi.  */
8937     case 507: value = 506; break;       /* uxth --> uxtb.  */
8938     case 506: value = 509; break;       /* uxtb --> lsr.  */
8939     case 509: value = 508; break;       /* lsr --> lsl.  */
8940     case 508: value = 505; break;       /* lsl --> ubfx.  */
8941     case 505: value = 504; break;       /* ubfx --> ubfiz.  */
8942     case 527: value = 526; break;       /* cset --> cinc.  */
8943     case 530: value = 529; break;       /* csetm --> cinv.  */
8944     case 768: value = 767; break;       /* uxtw --> mov.  */
8945     case 962: value = 961; break;       /* sevl --> sev.  */
8946     case 961: value = 960; break;       /* sev --> wfi.  */
8947     case 960: value = 959; break;       /* wfi --> wfe.  */
8948     case 959: value = 958; break;       /* wfe --> yield.  */
8949     case 958: value = 957; break;       /* yield --> nop.  */
8950     case 971: value = 970; break;       /* tlbi --> ic.  */
8951     case 970: value = 969; break;       /* ic --> dc.  */
8952     case 969: value = 968; break;       /* dc --> at.  */
8953     default: return NULL;
8954     }
8955
8956   return aarch64_opcode_table + value;
8957 }
8958
8959 int
8960 aarch64_extract_operand (const aarch64_operand *self,
8961                            aarch64_opnd_info *info,
8962                            aarch64_insn code, const aarch64_inst *inst)
8963 {
8964   /* Use the index as the key.  */
8965   int key = self - aarch64_operands;
8966   switch (key)
8967     {
8968     case 1:
8969     case 2:
8970     case 3:
8971     case 4:
8972     case 5:
8973     case 6:
8974     case 7:
8975     case 9:
8976     case 10:
8977     case 14:
8978     case 15:
8979     case 16:
8980     case 17:
8981     case 19:
8982     case 20:
8983     case 21:
8984     case 22:
8985     case 23:
8986     case 24:
8987     case 25:
8988     case 26:
8989     case 27:
8990     case 35:
8991     case 36:
8992       return aarch64_ext_regno (self, info, code, inst);
8993     case 8:
8994       return aarch64_ext_regrt_sysins (self, info, code, inst);
8995     case 11:
8996       return aarch64_ext_regno_pair (self, info, code, inst);
8997     case 12:
8998       return aarch64_ext_reg_extended (self, info, code, inst);
8999     case 13:
9000       return aarch64_ext_reg_shifted (self, info, code, inst);
9001     case 18:
9002       return aarch64_ext_ft (self, info, code, inst);
9003     case 28:
9004     case 29:
9005     case 30:
9006       return aarch64_ext_reglane (self, info, code, inst);
9007     case 31:
9008       return aarch64_ext_reglist (self, info, code, inst);
9009     case 32:
9010       return aarch64_ext_ldst_reglist (self, info, code, inst);
9011     case 33:
9012       return aarch64_ext_ldst_reglist_r (self, info, code, inst);
9013     case 34:
9014       return aarch64_ext_ldst_elemlist (self, info, code, inst);
9015     case 37:
9016     case 46:
9017     case 47:
9018     case 48:
9019     case 49:
9020     case 50:
9021     case 51:
9022     case 52:
9023     case 53:
9024     case 54:
9025     case 55:
9026     case 56:
9027     case 57:
9028     case 58:
9029     case 66:
9030     case 67:
9031     case 68:
9032     case 69:
9033     case 70:
9034       return aarch64_ext_imm (self, info, code, inst);
9035     case 38:
9036     case 39:
9037       return aarch64_ext_advsimd_imm_shift (self, info, code, inst);
9038     case 40:
9039     case 41:
9040     case 42:
9041       return aarch64_ext_advsimd_imm_modified (self, info, code, inst);
9042     case 43:
9043       return aarch64_ext_shll_imm (self, info, code, inst);
9044     case 59:
9045       return aarch64_ext_limm (self, info, code, inst);
9046     case 60:
9047       return aarch64_ext_aimm (self, info, code, inst);
9048     case 61:
9049       return aarch64_ext_imm_half (self, info, code, inst);
9050     case 62:
9051       return aarch64_ext_fbits (self, info, code, inst);
9052     case 64:
9053     case 65:
9054       return aarch64_ext_cond (self, info, code, inst);
9055     case 71:
9056     case 77:
9057       return aarch64_ext_addr_simple (self, info, code, inst);
9058     case 72:
9059       return aarch64_ext_addr_regoff (self, info, code, inst);
9060     case 73:
9061     case 74:
9062     case 75:
9063       return aarch64_ext_addr_simm (self, info, code, inst);
9064     case 76:
9065       return aarch64_ext_addr_uimm12 (self, info, code, inst);
9066     case 78:
9067       return aarch64_ext_simd_addr_post (self, info, code, inst);
9068     case 79:
9069       return aarch64_ext_sysreg (self, info, code, inst);
9070     case 80:
9071       return aarch64_ext_pstatefield (self, info, code, inst);
9072     case 81:
9073     case 82:
9074     case 83:
9075     case 84:
9076       return aarch64_ext_sysins_op (self, info, code, inst);
9077     case 85:
9078     case 86:
9079       return aarch64_ext_barrier (self, info, code, inst);
9080     case 87:
9081       return aarch64_ext_prfop (self, info, code, inst);
9082     default: assert (0); abort ();
9083     }
9084 }