opcodes/aarch64-dis-2.c

   1 /* This file is automatically generated by aarch64-gen.  Do not edit!  */
   2 /* Copyright (C) 2012-2017 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 1155;
  44                     }
  45                   else
  46                     {
  47                       /* 33222222222211111111110000000000
  48                          10987654321098765432109876543210
  49                          xxxxxxxxxxxxxxxxxxxxxxxx0000xxx1
  50                          adrp.  */
  51                       return 1156;
  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 910;
 119                                             }
 120                                           else
 121                                             {
 122                                               /* 33222222222211111111110000000000
 123                                                  10987654321098765432109876543210
 124                                                  xxxxxxxxxxxxxxx0xxxxx000x0010010
 125                                                  stxrh.  */
 126                                               return 916;
 127                                             }
 128                                         }
 129                                       else
 130                                         {
 131                                           /* 33222222222211111111110000000000
 132                                              10987654321098765432109876543210
 133                                              xxxxxxxxxxxxxxx0xxxxx000x00100x1
 134                                              stxr.  */
 135                                           return 922;
 136                                         }
 137                                     }
 138                                   else
 139                                     {
 140                                       if (((word >> 31) & 0x1) == 0)
 141                                         {
 142                                           /* 33222222222211111111110000000000
 143                                              10987654321098765432109876543210
 144                                              xxxxxxxxxxxxxxx0xxxxx100x00100x0
 145                                              casp.  */
 146                                           return 990;
 147                                         }
 148                                       else
 149                                         {
 150                                           /* 33222222222211111111110000000000
 151                                              10987654321098765432109876543210
 152                                              xxxxxxxxxxxxxxx0xxxxx100x00100x1
 153                                              stxp.  */
 154                                           return 924;
 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 911;
 171                                             }
 172                                           else
 173                                             {
 174                                               /* 33222222222211111111110000000000
 175                                                  10987654321098765432109876543210
 176                                                  xxxxxxxxxxxxxxx1xxxxx000x0010010
 177                                                  stlxrh.  */
 178                                               return 917;
 179                                             }
 180                                         }
 181                                       else
 182                                         {
 183                                           /* 33222222222211111111110000000000
 184                                              10987654321098765432109876543210
 185                                              xxxxxxxxxxxxxxx1xxxxx000x00100x1
 186                                              stlxr.  */
 187                                           return 923;
 188                                         }
 189                                     }
 190                                   else
 191                                     {
 192                                       if (((word >> 31) & 0x1) == 0)
 193                                         {
 194                                           /* 33222222222211111111110000000000
 195                                              10987654321098765432109876543210
 196                                              xxxxxxxxxxxxxxx1xxxxx100x00100x0
 197                                              caspl.  */
 198                                           return 992;
 199                                         }
 200                                       else
 201                                         {
 202                                           /* 33222222222211111111110000000000
 203                                              10987654321098765432109876543210
 204                                              xxxxxxxxxxxxxxx1xxxxx100x00100x1
 205                                              stlxp.  */
 206                                           return 925;
 207                                         }
 208                                     }
 209                                 }
 210                             }
 211                           else
 212                             {
 213                               /* 33222222222211111111110000000000
 214                                  10987654321098765432109876543210
 215                                  xxxxxxxxxxxxxxxxxxxxxx00x00101xx
 216                                  stnp.  */
 217                               return 941;
 218                             }
 219                         }
 220                       else
 221                         {
 222                           if (((word >> 29) & 0x1) == 0)
 223                             {
 224                               if (((word >> 15) & 0x1) == 0)
 225                                 {
 226                                   if (((word >> 21) & 0x1) == 0)
 227                                     {
 228                                       if (((word >> 31) & 0x1) == 0)
 229                                         {
 230                                           /* 33222222222211111111110000000000
 231                                              10987654321098765432109876543210
 232                                              xxxxxxxxxxxxxxx0xxxxx001x00100x0
 233                                              stllrb.  */
 234                                           return 939;
 235                                         }
 236                                       else
 237                                         {
 238                                           /* 33222222222211111111110000000000
 239                                              10987654321098765432109876543210
 240                                              xxxxxxxxxxxxxxx0xxxxx001x00100x1
 241                                              stllr.  */
 242                                           return 938;
 243                                         }
 244                                     }
 245                                   else
 246                                     {
 247                                       if (((word >> 31) & 0x1) == 0)
 248                                         {
 249                                           if (((word >> 30) & 0x1) == 0)
 250                                             {
 251                                               /* 33222222222211111111110000000000
 252                                                  10987654321098765432109876543210
 253                                                  xxxxxxxxxxxxxxx0xxxxx101x0010000
 254                                                  casb.  */
 255                                               return 978;
 256                                             }
 257                                           else
 258                                             {
 259                                               /* 33222222222211111111110000000000
 260                                                  10987654321098765432109876543210
 261                                                  xxxxxxxxxxxxxxx0xxxxx101x0010010
 262                                                  cash.  */
 263                                               return 979;
 264                                             }
 265                                         }
 266                                       else
 267                                         {
 268                                           /* 33222222222211111111110000000000
 269                                              10987654321098765432109876543210
 270                                              xxxxxxxxxxxxxxx0xxxxx101x00100x1
 271                                              cas.  */
 272                                           return 980;
 273                                         }
 274                                     }
 275                                 }
 276                               else
 277                                 {
 278                                   if (((word >> 21) & 0x1) == 0)
 279                                     {
 280                                       if (((word >> 31) & 0x1) == 0)
 281                                         {
 282                                           if (((word >> 30) & 0x1) == 0)
 283                                             {
 284                                               /* 33222222222211111111110000000000
 285                                                  10987654321098765432109876543210
 286                                                  xxxxxxxxxxxxxxx1xxxxx001x0010000
 287                                                  stlrb.  */
 288                                               return 914;
 289                                             }
 290                                           else
 291                                             {
 292                                               /* 33222222222211111111110000000000
 293                                                  10987654321098765432109876543210
 294                                                  xxxxxxxxxxxxxxx1xxxxx001x0010010
 295                                                  stlrh.  */
 296                                               return 920;
 297                                             }
 298                                         }
 299                                       else
 300                                         {
 301                                           /* 33222222222211111111110000000000
 302                                              10987654321098765432109876543210
 303                                              xxxxxxxxxxxxxxx1xxxxx001x00100x1
 304                                              stlr.  */
 305                                           return 930;
 306                                         }
 307                                     }
 308                                   else
 309                                     {
 310                                       if (((word >> 31) & 0x1) == 0)
 311                                         {
 312                                           if (((word >> 30) & 0x1) == 0)
 313                                             {
 314                                               /* 33222222222211111111110000000000
 315                                                  10987654321098765432109876543210
 316                                                  xxxxxxxxxxxxxxx1xxxxx101x0010000
 317                                                  caslb.  */
 318                                               return 982;
 319                                             }
 320                                           else
 321                                             {
 322                                               /* 33222222222211111111110000000000
 323                                                  10987654321098765432109876543210
 324                                                  xxxxxxxxxxxxxxx1xxxxx101x0010010
 325                                                  caslh.  */
 326                                               return 985;
 327                                             }
 328                                         }
 329                                       else
 330                                         {
 331                                           /* 33222222222211111111110000000000
 332                                              10987654321098765432109876543210
 333                                              xxxxxxxxxxxxxxx1xxxxx101x00100x1
 334                                              casl.  */
 335                                           return 988;
 336                                         }
 337                                     }
 338                                 }
 339                             }
 340                           else
 341                             {
 342                               /* 33222222222211111111110000000000
 343                                  10987654321098765432109876543210
 344                                  xxxxxxxxxxxxxxxxxxxxxx01x00101xx
 345                                  stp.  */
 346                               return 950;
 347                             }
 348                         }
 349                     }
 350                   else
 351                     {
 352                       if (((word >> 23) & 0x1) == 0)
 353                         {
 354                           if (((word >> 29) & 0x1) == 0)
 355                             {
 356                               if (((word >> 15) & 0x1) == 0)
 357                                 {
 358                                   if (((word >> 21) & 0x1) == 0)
 359                                     {
 360                                       if (((word >> 31) & 0x1) == 0)
 361                                         {
 362                                           if (((word >> 30) & 0x1) == 0)
 363                                             {
 364                                               /* 33222222222211111111110000000000
 365                                                  10987654321098765432109876543210
 366                                                  xxxxxxxxxxxxxxx0xxxxx010x0010000
 367                                                  ldxrb.  */
 368                                               return 912;
 369                                             }
 370                                           else
 371                                             {
 372                                               /* 33222222222211111111110000000000
 373                                                  10987654321098765432109876543210
 374                                                  xxxxxxxxxxxxxxx0xxxxx010x0010010
 375                                                  ldxrh.  */
 376                                               return 918;
 377                                             }
 378                                         }
 379                                       else
 380                                         {
 381                                           /* 33222222222211111111110000000000
 382                                              10987654321098765432109876543210
 383                                              xxxxxxxxxxxxxxx0xxxxx010x00100x1
 384                                              ldxr.  */
 385                                           return 926;
 386                                         }
 387                                     }
 388                                   else
 389                                     {
 390                                       if (((word >> 31) & 0x1) == 0)
 391                                         {
 392                                           /* 33222222222211111111110000000000
 393                                              10987654321098765432109876543210
 394                                              xxxxxxxxxxxxxxx0xxxxx110x00100x0
 395                                              caspa.  */
 396                                           return 991;
 397                                         }
 398                                       else
 399                                         {
 400                                           /* 33222222222211111111110000000000
 401                                              10987654321098765432109876543210
 402                                              xxxxxxxxxxxxxxx0xxxxx110x00100x1
 403                                              ldxp.  */
 404                                           return 928;
 405                                         }
 406                                     }
 407                                 }
 408                               else
 409                                 {
 410                                   if (((word >> 21) & 0x1) == 0)
 411                                     {
 412                                       if (((word >> 31) & 0x1) == 0)
 413                                         {
 414                                           if (((word >> 30) & 0x1) == 0)
 415                                             {
 416                                               /* 33222222222211111111110000000000
 417                                                  10987654321098765432109876543210
 418                                                  xxxxxxxxxxxxxxx1xxxxx010x0010000
 419                                                  ldaxrb.  */
 420                                               return 913;
 421                                             }
 422                                           else
 423                                             {
 424                                               /* 33222222222211111111110000000000
 425                                                  10987654321098765432109876543210
 426                                                  xxxxxxxxxxxxxxx1xxxxx010x0010010
 427                                                  ldaxrh.  */
 428                                               return 919;
 429                                             }
 430                                         }
 431                                       else
 432                                         {
 433                                           /* 33222222222211111111110000000000
 434                                              10987654321098765432109876543210
 435                                              xxxxxxxxxxxxxxx1xxxxx010x00100x1
 436                                              ldaxr.  */
 437                                           return 927;
 438                                         }
 439                                     }
 440                                   else
 441                                     {
 442                                       if (((word >> 31) & 0x1) == 0)
 443                                         {
 444                                           /* 33222222222211111111110000000000
 445                                              10987654321098765432109876543210
 446                                              xxxxxxxxxxxxxxx1xxxxx110x00100x0
 447                                              caspal.  */
 448                                           return 993;
 449                                         }
 450                                       else
 451                                         {
 452                                           /* 33222222222211111111110000000000
 453                                              10987654321098765432109876543210
 454                                              xxxxxxxxxxxxxxx1xxxxx110x00100x1
 455                                              ldaxp.  */
 456                                           return 929;
 457                                         }
 458                                     }
 459                                 }
 460                             }
 461                           else
 462                             {
 463                               if (((word >> 30) & 0x1) == 0)
 464                                 {
 465                                   /* 33222222222211111111110000000000
 466                                      10987654321098765432109876543210
 467                                      xxxxxxxxxxxxxxxxxxxxxx10x001010x
 468                                      ldnp.  */
 469                                   return 942;
 470                                 }
 471                               else
 472                                 {
 473                                   /* 33222222222211111111110000000000
 474                                      10987654321098765432109876543210
 475                                      xxxxxxxxxxxxxxxxxxxxxx10x001011x
 476                                      ldpsw.  */
 477                                   return 949;
 478                                 }
 479                             }
 480                         }
 481                       else
 482                         {
 483                           if (((word >> 29) & 0x1) == 0)
 484                             {
 485                               if (((word >> 15) & 0x1) == 0)
 486                                 {
 487                                   if (((word >> 21) & 0x1) == 0)
 488                                     {
 489                                       if (((word >> 31) & 0x1) == 0)
 490                                         {
 491                                           if (((word >> 30) & 0x1) == 0)
 492                                             {
 493                                               /* 33222222222211111111110000000000
 494                                                  10987654321098765432109876543210
 495                                                  xxxxxxxxxxxxxxx0xxxxx011x0010000
 496                                                  ldlarb.  */
 497                                               return 936;
 498                                             }
 499                                           else
 500                                             {
 501                                               /* 33222222222211111111110000000000
 502                                                  10987654321098765432109876543210
 503                                                  xxxxxxxxxxxxxxx0xxxxx011x0010010
 504                                                  ldlarh.  */
 505                                               return 937;
 506                                             }
 507                                         }
 508                                       else
 509                                         {
 510                                           /* 33222222222211111111110000000000
 511                                              10987654321098765432109876543210
 512                                              xxxxxxxxxxxxxxx0xxxxx011x00100x1
 513                                              ldlar.  */
 514                                           return 935;
 515                                         }
 516                                     }
 517                                   else
 518                                     {
 519                                       if (((word >> 31) & 0x1) == 0)
 520                                         {
 521                                           if (((word >> 30) & 0x1) == 0)
 522                                             {
 523                                               /* 33222222222211111111110000000000
 524                                                  10987654321098765432109876543210
 525                                                  xxxxxxxxxxxxxxx0xxxxx111x0010000
 526                                                  casab.  */
 527                                               return 981;
 528                                             }
 529                                           else
 530                                             {
 531                                               /* 33222222222211111111110000000000
 532                                                  10987654321098765432109876543210
 533                                                  xxxxxxxxxxxxxxx0xxxxx111x0010010
 534                                                  casah.  */
 535                                               return 984;
 536                                             }
 537                                         }
 538                                       else
 539                                         {
 540                                           /* 33222222222211111111110000000000
 541                                              10987654321098765432109876543210
 542                                              xxxxxxxxxxxxxxx0xxxxx111x00100x1
 543                                              casa.  */
 544                                           return 987;
 545                                         }
 546                                     }
 547                                 }
 548                               else
 549                                 {
 550                                   if (((word >> 21) & 0x1) == 0)
 551                                     {
 552                                       if (((word >> 31) & 0x1) == 0)
 553                                         {
 554                                           if (((word >> 30) & 0x1) == 0)
 555                                             {
 556                                               /* 33222222222211111111110000000000
 557                                                  10987654321098765432109876543210
 558                                                  xxxxxxxxxxxxxxx1xxxxx011x0010000
 559                                                  ldarb.  */
 560                                               return 915;
 561                                             }
 562                                           else
 563                                             {
 564                                               /* 33222222222211111111110000000000
 565                                                  10987654321098765432109876543210
 566                                                  xxxxxxxxxxxxxxx1xxxxx011x0010010
 567                                                  ldarh.  */
 568                                               return 921;
 569                                             }
 570                                         }
 571                                       else
 572                                         {
 573                                           /* 33222222222211111111110000000000
 574                                              10987654321098765432109876543210
 575                                              xxxxxxxxxxxxxxx1xxxxx011x00100x1
 576                                              ldar.  */
 577                                           return 931;
 578                                         }
 579                                     }
 580                                   else
 581                                     {
 582                                       if (((word >> 31) & 0x1) == 0)
 583                                         {
 584                                           if (((word >> 30) & 0x1) == 0)
 585                                             {
 586                                               /* 33222222222211111111110000000000
 587                                                  10987654321098765432109876543210
 588                                                  xxxxxxxxxxxxxxx1xxxxx111x0010000
 589                                                  casalb.  */
 590                                               return 983;
 591                                             }
 592                                           else
 593                                             {
 594                                               /* 33222222222211111111110000000000
 595                                                  10987654321098765432109876543210
 596                                                  xxxxxxxxxxxxxxx1xxxxx111x0010010
 597                                                  casalh.  */
 598                                               return 986;
 599                                             }
 600                                         }
 601                                       else
 602                                         {
 603                                           /* 33222222222211111111110000000000
 604                                              10987654321098765432109876543210
 605                                              xxxxxxxxxxxxxxx1xxxxx111x00100x1
 606                                              casal.  */
 607                                           return 989;
 608                                         }
 609                                     }
 610                                 }
 611                             }
 612                           else
 613                             {
 614                               if (((word >> 30) & 0x1) == 0)
 615                                 {
 616                                   /* 33222222222211111111110000000000
 617                                      10987654321098765432109876543210
 618                                      xxxxxxxxxxxxxxxxxxxxxx11x001010x
 619                                      ldp.  */
 620                                   return 951;
 621                                 }
 622                               else
 623                                 {
 624                                   /* 33222222222211111111110000000000
 625                                      10987654321098765432109876543210
 626                                      xxxxxxxxxxxxxxxxxxxxxx11x001011x
 627                                      ldpsw.  */
 628                                   return 954;
 629                                 }
 630                             }
 631                         }
 632                     }
 633                 }
 634               else
 635                 {
 636                   if (((word >> 24) & 0x1) == 0)
 637                     {
 638                       if (((word >> 29) & 0x1) == 0)
 639                         {
 640                           if (((word >> 31) & 0x1) == 0)
 641                             {
 642                               /* 33222222222211111111110000000000
 643                                  10987654321098765432109876543210
 644                                  xxxxxxxxxxxxxxxxxxxxxxxx000110x0
 645                                  ldr.  */
 646                               return 955;
 647                             }
 648                           else
 649                             {
 650                               if (((word >> 30) & 0x1) == 0)
 651                                 {
 652                                   /* 33222222222211111111110000000000
 653                                      10987654321098765432109876543210
 654                                      xxxxxxxxxxxxxxxxxxxxxxxx00011001
 655                                      ldrsw.  */
 656                                   return 957;
 657                                 }
 658                               else
 659                                 {
 660                                   /* 33222222222211111111110000000000
 661                                      10987654321098765432109876543210
 662                                      xxxxxxxxxxxxxxxxxxxxxxxx00011011
 663                                      prfm.  */
 664                                   return 958;
 665                                 }
 666                             }
 667                         }
 668                       else
 669                         {
 670                           if (((word >> 10) & 0x1) == 0)
 671                             {
 672                               if (((word >> 11) & 0x1) == 0)
 673                                 {
 674                                   if (((word >> 21) & 0x1) == 0)
 675                                     {
 676                                       if (((word >> 23) & 0x1) == 0)
 677                                         {
 678                                           if (((word >> 22) & 0x1) == 0)
 679                                             {
 680                                               if (((word >> 31) & 0x1) == 0)
 681                                                 {
 682                                                   if (((word >> 30) & 0x1) == 0)
 683                                                     {
 684                                                       /* 33222222222211111111110000000000
 685                                                          10987654321098765432109876543210
 686                                                          xxxxxxxxxx00xxxxxxxxx00000011100
 687                                                          sturb.  */
 688                                                       return 896;
 689                                                     }
 690                                                   else
 691                                                     {
 692                                                       /* 33222222222211111111110000000000
 693                                                          10987654321098765432109876543210
 694                                                          xxxxxxxxxx00xxxxxxxxx00000011110
 695                                                          sturh.  */
 696                                                       return 901;
 697                                                     }
 698                                                 }
 699                                               else
 700                                                 {
 701                                                   /* 33222222222211111111110000000000
 702                                                      10987654321098765432109876543210
 703                                                      xxxxxxxxxx00xxxxxxxxx000000111x1
 704                                                      stur.  */
 705                                                   return 904;
 706                                                 }
 707                                             }
 708                                           else
 709                                             {
 710                                               if (((word >> 31) & 0x1) == 0)
 711                                                 {
 712                                                   if (((word >> 30) & 0x1) == 0)
 713                                                     {
 714                                                       /* 33222222222211111111110000000000
 715                                                          10987654321098765432109876543210
 716                                                          xxxxxxxxxx00xxxxxxxxx01000011100
 717                                                          ldurb.  */
 718                                                       return 897;
 719                                                     }
 720                                                   else
 721                                                     {
 722                                                       /* 33222222222211111111110000000000
 723                                                          10987654321098765432109876543210
 724                                                          xxxxxxxxxx00xxxxxxxxx01000011110
 725                                                          ldurh.  */
 726                                                       return 902;
 727                                                     }
 728                                                 }
 729                                               else
 730                                                 {
 731                                                   /* 33222222222211111111110000000000
 732                                                      10987654321098765432109876543210
 733                                                      xxxxxxxxxx00xxxxxxxxx010000111x1
 734                                                      ldur.  */
 735                                                   return 905;
 736                                                 }
 737                                             }
 738                                         }
 739                                       else
 740                                         {
 741                                           if (((word >> 30) & 0x1) == 0)
 742                                             {
 743                                               if (((word >> 31) & 0x1) == 0)
 744                                                 {
 745                                                   /* 33222222222211111111110000000000
 746                                                      10987654321098765432109876543210
 747                                                      xxxxxxxxxx00xxxxxxxxx0x100011100
 748                                                      ldursb.  */
 749                                                   return 898;
 750                                                 }
 751                                               else
 752                                                 {
 753                                                   /* 33222222222211111111110000000000
 754                                                      10987654321098765432109876543210
 755                                                      xxxxxxxxxx00xxxxxxxxx0x100011101
 756                                                      ldursw.  */
 757                                                   return 906;
 758                                                 }
 759                                             }
 760                                           else
 761                                             {
 762                                               if (((word >> 31) & 0x1) == 0)
 763                                                 {
 764                                                   /* 33222222222211111111110000000000
 765                                                      10987654321098765432109876543210
 766                                                      xxxxxxxxxx00xxxxxxxxx0x100011110
 767                                                      ldursh.  */
 768                                                   return 903;
 769                                                 }
 770                                               else
 771                                                 {
 772                                                   /* 33222222222211111111110000000000
 773                                                      10987654321098765432109876543210
 774                                                      xxxxxxxxxx00xxxxxxxxx0x100011111
 775                                                      prfum.  */
 776                                                   return 907;
 777                                                 }
 778                                             }
 779                                         }
 780                                     }
 781                                   else
 782                                     {
 783                                       if (((word >> 12) & 0x1) == 0)
 784                                         {
 785                                           if (((word >> 13) & 0x1) == 0)
 786                                             {
 787                                               if (((word >> 14) & 0x1) == 0)
 788                                                 {
 789                                                   if (((word >> 15) & 0x1) == 0)
 790                                                     {
 791                                                       if (((word >> 22) & 0x1) == 0)
 792                                                         {
 793                                                           if (((word >> 23) & 0x1) == 0)
 794                                                             {
 795                                                               if (((word >> 31) & 0x1) == 0)
 796                                                                 {
 797                                                                   if (((word >> 30) & 0x1) == 0)
 798                                                                     {
 799                                                                       /* 33222222222211111111110000000000
 800                                                                          10987654321098765432109876543210
 801                                                                          xxxxxxxxxx000000xxxxx10000011100
 802                                                                          ldaddb.  */
 803                                                                       return 1006;
 804                                                                     }
 805                                                                   else
 806                                                                     {
 807                                                                       /* 33222222222211111111110000000000
 808                                                                          10987654321098765432109876543210
 809                                                                          xxxxxxxxxx000000xxxxx10000011110
 810                                                                          ldaddh.  */
 811                                                                       return 1007;
 812                                                                     }
 813                                                                 }
 814                                                               else
 815                                                                 {
 816                                                                   /* 33222222222211111111110000000000
 817                                                                      10987654321098765432109876543210
 818                                                                      xxxxxxxxxx000000xxxxx100000111x1
 819                                                                      ldadd.  */
 820                                                                   return 1008;
 821                                                                 }
 822                                                             }
 823                                                           else
 824                                                             {
 825                                                               if (((word >> 31) & 0x1) == 0)
 826                                                                 {
 827                                                                   if (((word >> 30) & 0x1) == 0)
 828                                                                     {
 829                                                                       /* 33222222222211111111110000000000
 830                                                                          10987654321098765432109876543210
 831                                                                          xxxxxxxxxx000000xxxxx10100011100
 832                                                                          ldaddab.  */
 833                                                                       return 1009;
 834                                                                     }
 835                                                                   else
 836                                                                     {
 837                                                                       /* 33222222222211111111110000000000
 838                                                                          10987654321098765432109876543210
 839                                                                          xxxxxxxxxx000000xxxxx10100011110
 840                                                                          ldaddah.  */
 841                                                                       return 1012;
 842                                                                     }
 843                                                                 }
 844                                                               else
 845                                                                 {
 846                                                                   /* 33222222222211111111110000000000
 847                                                                      10987654321098765432109876543210
 848                                                                      xxxxxxxxxx000000xxxxx101000111x1
 849                                                                      ldadda.  */
 850                                                                   return 1015;
 851                                                                 }
 852                                                             }
 853                                                         }
 854                                                       else
 855                                                         {
 856                                                           if (((word >> 23) & 0x1) == 0)
 857                                                             {
 858                                                               if (((word >> 31) & 0x1) == 0)
 859                                                                 {
 860                                                                   if (((word >> 30) & 0x1) == 0)
 861                                                                     {
 862                                                                       /* 33222222222211111111110000000000
 863                                                                          10987654321098765432109876543210
 864                                                                          xxxxxxxxxx000000xxxxx11000011100
 865                                                                          ldaddlb.  */
 866                                                                       return 1010;
 867                                                                     }
 868                                                                   else
 869                                                                     {
 870                                                                       /* 33222222222211111111110000000000
 871                                                                          10987654321098765432109876543210
 872                                                                          xxxxxxxxxx000000xxxxx11000011110
 873                                                                          ldaddlh.  */
 874                                                                       return 1013;
 875                                                                     }
 876                                                                 }
 877                                                               else
 878                                                                 {
 879                                                                   /* 33222222222211111111110000000000
 880                                                                      10987654321098765432109876543210
 881                                                                      xxxxxxxxxx000000xxxxx110000111x1
 882                                                                      ldaddl.  */
 883                                                                   return 1016;
 884                                                                 }
 885                                                             }
 886                                                           else
 887                                                             {
 888                                                               if (((word >> 31) & 0x1) == 0)
 889                                                                 {
 890                                                                   if (((word >> 30) & 0x1) == 0)
 891                                                                     {
 892                                                                       /* 33222222222211111111110000000000
 893                                                                          10987654321098765432109876543210
 894                                                                          xxxxxxxxxx000000xxxxx11100011100
 895                                                                          ldaddalb.  */
 896                                                                       return 1011;
 897                                                                     }
 898                                                                   else
 899                                                                     {
 900                                                                       /* 33222222222211111111110000000000
 901                                                                          10987654321098765432109876543210
 902                                                                          xxxxxxxxxx000000xxxxx11100011110
 903                                                                          ldaddalh.  */
 904                                                                       return 1014;
 905                                                                     }
 906                                                                 }
 907                                                               else
 908                                                                 {
 909                                                                   /* 33222222222211111111110000000000
 910                                                                      10987654321098765432109876543210
 911                                                                      xxxxxxxxxx000000xxxxx111000111x1
 912                                                                      ldaddal.  */
 913                                                                   return 1017;
 914                                                                 }
 915                                                             }
 916                                                         }
 917                                                     }
 918                                                   else
 919                                                     {
 920                                                       if (((word >> 22) & 0x1) == 0)
 921                                                         {
 922                                                           if (((word >> 23) & 0x1) == 0)
 923                                                             {
 924                                                               if (((word >> 31) & 0x1) == 0)
 925                                                                 {
 926                                                                   if (((word >> 30) & 0x1) == 0)
 927                                                                     {
 928                                                                       /* 33222222222211111111110000000000
 929                                                                          10987654321098765432109876543210
 930                                                                          xxxxxxxxxx000001xxxxx10000011100
 931                                                                          swpb.  */
 932                                                                       return 994;
 933                                                                     }
 934                                                                   else
 935                                                                     {
 936                                                                       /* 33222222222211111111110000000000
 937                                                                          10987654321098765432109876543210
 938                                                                          xxxxxxxxxx000001xxxxx10000011110
 939                                                                          swph.  */
 940                                                                       return 995;
 941                                                                     }
 942                                                                 }
 943                                                               else
 944                                                                 {
 945                                                                   /* 33222222222211111111110000000000
 946                                                                      10987654321098765432109876543210
 947                                                                      xxxxxxxxxx000001xxxxx100000111x1
 948                                                                      swp.  */
 949                                                                   return 996;
 950                                                                 }
 951                                                             }
 952                                                           else
 953                                                             {
 954                                                               if (((word >> 31) & 0x1) == 0)
 955                                                                 {
 956                                                                   if (((word >> 30) & 0x1) == 0)
 957                                                                     {
 958                                                                       /* 33222222222211111111110000000000
 959                                                                          10987654321098765432109876543210
 960                                                                          xxxxxxxxxx000001xxxxx10100011100
 961                                                                          swpab.  */
 962                                                                       return 997;
 963                                                                     }
 964                                                                   else
 965                                                                     {
 966                                                                       /* 33222222222211111111110000000000
 967                                                                          10987654321098765432109876543210
 968                                                                          xxxxxxxxxx000001xxxxx10100011110
 969                                                                          swpah.  */
 970                                                                       return 1000;
 971                                                                     }
 972                                                                 }
 973                                                               else
 974                                                                 {
 975                                                                   /* 33222222222211111111110000000000
 976                                                                      10987654321098765432109876543210
 977                                                                      xxxxxxxxxx000001xxxxx101000111x1
 978                                                                      swpa.  */
 979                                                                   return 1003;
 980                                                                 }
 981                                                             }
 982                                                         }
 983                                                       else
 984                                                         {
 985                                                           if (((word >> 23) & 0x1) == 0)
 986                                                             {
 987                                                               if (((word >> 31) & 0x1) == 0)
 988                                                                 {
 989                                                                   if (((word >> 30) & 0x1) == 0)
 990                                                                     {
 991                                                                       /* 33222222222211111111110000000000
 992                                                                          10987654321098765432109876543210
 993                                                                          xxxxxxxxxx000001xxxxx11000011100
 994                                                                          swplb.  */
 995                                                                       return 998;
 996                                                                     }
 997                                                                   else
 998                                                                     {
 999                                                                       /* 33222222222211111111110000000000
1000                                                                          10987654321098765432109876543210
1001                                                                          xxxxxxxxxx000001xxxxx11000011110
1002                                                                          swplh.  */
1003                                                                       return 1001;
1004                                                                     }
1005                                                                 }
1006                                                               else
1007                                                                 {
1008                                                                   /* 33222222222211111111110000000000
1009                                                                      10987654321098765432109876543210
1010                                                                      xxxxxxxxxx000001xxxxx110000111x1
1011                                                                      swpl.  */
1012                                                                   return 1004;
1013                                                                 }
1014                                                             }
1015                                                           else
1016                                                             {
1017                                                               if (((word >> 31) & 0x1) == 0)
1018                                                                 {
1019                                                                   if (((word >> 30) & 0x1) == 0)
1020                                                                     {
1021                                                                       /* 33222222222211111111110000000000
1022                                                                          10987654321098765432109876543210
1023                                                                          xxxxxxxxxx000001xxxxx11100011100
1024                                                                          swpalb.  */
1025                                                                       return 999;
1026                                                                     }
1027                                                                   else
1028                                                                     {
1029                                                                       /* 33222222222211111111110000000000
1030                                                                          10987654321098765432109876543210
1031                                                                          xxxxxxxxxx000001xxxxx11100011110
1032                                                                          swpalh.  */
1033                                                                       return 1002;
1034                                                                     }
1035                                                                 }
1036                                                               else
1037                                                                 {
1038                                                                   /* 33222222222211111111110000000000
1039                                                                      10987654321098765432109876543210
1040                                                                      xxxxxxxxxx000001xxxxx111000111x1
1041                                                                      swpal.  */
1042                                                                   return 1005;
1043                                                                 }
1044                                                             }
1045                                                         }
1046                                                     }
1047                                                 }
1048                                               else
1049                                                 {
1050                                                   if (((word >> 15) & 0x1) == 0)
1051                                                     {
1052                                                       if (((word >> 22) & 0x1) == 0)
1053                                                         {
1054                                                           if (((word >> 23) & 0x1) == 0)
1055                                                             {
1056                                                               if (((word >> 31) & 0x1) == 0)
1057                                                                 {
1058                                                                   if (((word >> 30) & 0x1) == 0)
1059                                                                     {
1060                                                                       /* 33222222222211111111110000000000
1061                                                                          10987654321098765432109876543210
1062                                                                          xxxxxxxxxx000010xxxxx10000011100
1063                                                                          ldsmaxb.  */
1064                                                                       return 1054;
1065                                                                     }
1066                                                                   else
1067                                                                     {
1068                                                                       /* 33222222222211111111110000000000
1069                                                                          10987654321098765432109876543210
1070                                                                          xxxxxxxxxx000010xxxxx10000011110
1071                                                                          ldsmaxh.  */
1072                                                                       return 1055;
1073                                                                     }
1074                                                                 }
1075                                                               else
1076                                                                 {
1077                                                                   /* 33222222222211111111110000000000
1078                                                                      10987654321098765432109876543210
1079                                                                      xxxxxxxxxx000010xxxxx100000111x1
1080                                                                      ldsmax.  */
1081                                                                   return 1056;
1082                                                                 }
1083                                                             }
1084                                                           else
1085                                                             {
1086                                                               if (((word >> 31) & 0x1) == 0)
1087                                                                 {
1088                                                                   if (((word >> 30) & 0x1) == 0)
1089                                                                     {
1090                                                                       /* 33222222222211111111110000000000
1091                                                                          10987654321098765432109876543210
1092                                                                          xxxxxxxxxx000010xxxxx10100011100
1093                                                                          ldsmaxab.  */
1094                                                                       return 1057;
1095                                                                     }
1096                                                                   else
1097                                                                     {
1098                                                                       /* 33222222222211111111110000000000
1099                                                                          10987654321098765432109876543210
1100                                                                          xxxxxxxxxx000010xxxxx10100011110
1101                                                                          ldsmaxah.  */
1102                                                                       return 1060;
1103                                                                     }
1104                                                                 }
1105                                                               else
1106                                                                 {
1107                                                                   /* 33222222222211111111110000000000
1108                                                                      10987654321098765432109876543210
1109                                                                      xxxxxxxxxx000010xxxxx101000111x1
1110                                                                      ldsmaxa.  */
1111                                                                   return 1063;
1112                                                                 }
1113                                                             }
1114                                                         }
1115                                                       else
1116                                                         {
1117                                                           if (((word >> 23) & 0x1) == 0)
1118                                                             {
1119                                                               if (((word >> 31) & 0x1) == 0)
1120                                                                 {
1121                                                                   if (((word >> 30) & 0x1) == 0)
1122                                                                     {
1123                                                                       /* 33222222222211111111110000000000
1124                                                                          10987654321098765432109876543210
1125                                                                          xxxxxxxxxx000010xxxxx11000011100
1126                                                                          ldsmaxlb.  */
1127                                                                       return 1058;
1128                                                                     }
1129                                                                   else
1130                                                                     {
1131                                                                       /* 33222222222211111111110000000000
1132                                                                          10987654321098765432109876543210
1133                                                                          xxxxxxxxxx000010xxxxx11000011110
1134                                                                          ldsmaxlh.  */
1135                                                                       return 1061;
1136                                                                     }
1137                                                                 }
1138                                                               else
1139                                                                 {
1140                                                                   /* 33222222222211111111110000000000
1141                                                                      10987654321098765432109876543210
1142                                                                      xxxxxxxxxx000010xxxxx110000111x1
1143                                                                      ldsmaxl.  */
1144                                                                   return 1064;
1145                                                                 }
1146                                                             }
1147                                                           else
1148                                                             {
1149                                                               if (((word >> 31) & 0x1) == 0)
1150                                                                 {
1151                                                                   if (((word >> 30) & 0x1) == 0)
1152                                                                     {
1153                                                                       /* 33222222222211111111110000000000
1154                                                                          10987654321098765432109876543210
1155                                                                          xxxxxxxxxx000010xxxxx11100011100
1156                                                                          ldsmaxalb.  */
1157                                                                       return 1059;
1158                                                                     }
1159                                                                   else
1160                                                                     {
1161                                                                       /* 33222222222211111111110000000000
1162                                                                          10987654321098765432109876543210
1163                                                                          xxxxxxxxxx000010xxxxx11100011110
1164                                                                          ldsmaxalh.  */
1165                                                                       return 1062;
1166                                                                     }
1167                                                                 }
1168                                                               else
1169                                                                 {
1170                                                                   /* 33222222222211111111110000000000
1171                                                                      10987654321098765432109876543210
1172                                                                      xxxxxxxxxx000010xxxxx111000111x1
1173                                                                      ldsmaxal.  */
1174                                                                   return 1065;
1175                                                                 }
1176                                                             }
1177                                                         }
1178                                                     }
1179                                                   else
1180                                                     {
1181                                                       if (((word >> 31) & 0x1) == 0)
1182                                                         {
1183                                                           if (((word >> 30) & 0x1) == 0)
1184                                                             {
1185                                                               /* 33222222222211111111110000000000
1186                                                                  10987654321098765432109876543210
1187                                                                  xxxxxxxxxx000011xxxxx1xx00011100
1188                                                                  ldaprb.  */
1189                                                               return 932;
1190                                                             }
1191                                                           else
1192                                                             {
1193                                                               /* 33222222222211111111110000000000
1194                                                                  10987654321098765432109876543210
1195                                                                  xxxxxxxxxx000011xxxxx1xx00011110
1196                                                                  ldaprh.  */
1197                                                               return 933;
1198                                                             }
1199                                                         }
1200                                                       else
1201                                                         {
1202                                                           /* 33222222222211111111110000000000
1203                                                              10987654321098765432109876543210
1204                                                              xxxxxxxxxx000011xxxxx1xx000111x1
1205                                                              ldapr.  */
1206                                                           return 934;
1207                                                         }
1208                                                     }
1209                                                 }
1210                                             }
1211                                           else
1212                                             {
1213                                               if (((word >> 14) & 0x1) == 0)
1214                                                 {
1215                                                   if (((word >> 22) & 0x1) == 0)
1216                                                     {
1217                                                       if (((word >> 23) & 0x1) == 0)
1218                                                         {
1219                                                           if (((word >> 31) & 0x1) == 0)
1220                                                             {
1221                                                               if (((word >> 30) & 0x1) == 0)
1222                                                                 {
1223                                                                   /* 33222222222211111111110000000000
1224                                                                      10987654321098765432109876543210
1225                                                                      xxxxxxxxxx00010xxxxxx10000011100
1226                                                                      ldeorb.  */
1227                                                                   return 1030;
1228                                                                 }
1229                                                               else
1230                                                                 {
1231                                                                   /* 33222222222211111111110000000000
1232                                                                      10987654321098765432109876543210
1233                                                                      xxxxxxxxxx00010xxxxxx10000011110
1234                                                                      ldeorh.  */
1235                                                                   return 1031;
1236                                                                 }
1237                                                             }
1238                                                           else
1239                                                             {
1240                                                               /* 33222222222211111111110000000000
1241                                                                  10987654321098765432109876543210
1242                                                                  xxxxxxxxxx00010xxxxxx100000111x1
1243                                                                  ldeor.  */
1244                                                               return 1032;
1245                                                             }
1246                                                         }
1247                                                       else
1248                                                         {
1249                                                           if (((word >> 31) & 0x1) == 0)
1250                                                             {
1251                                                               if (((word >> 30) & 0x1) == 0)
1252                                                                 {
1253                                                                   /* 33222222222211111111110000000000
1254                                                                      10987654321098765432109876543210
1255                                                                      xxxxxxxxxx00010xxxxxx10100011100
1256                                                                      ldeorab.  */
1257                                                                   return 1033;
1258                                                                 }
1259                                                               else
1260                                                                 {
1261                                                                   /* 33222222222211111111110000000000
1262                                                                      10987654321098765432109876543210
1263                                                                      xxxxxxxxxx00010xxxxxx10100011110
1264                                                                      ldeorah.  */
1265                                                                   return 1036;
1266                                                                 }
1267                                                             }
1268                                                           else
1269                                                             {
1270                                                               /* 33222222222211111111110000000000
1271                                                                  10987654321098765432109876543210
1272                                                                  xxxxxxxxxx00010xxxxxx101000111x1
1273                                                                  ldeora.  */
1274                                                               return 1039;
1275                                                             }
1276                                                         }
1277                                                     }
1278                                                   else
1279                                                     {
1280                                                       if (((word >> 23) & 0x1) == 0)
1281                                                         {
1282                                                           if (((word >> 31) & 0x1) == 0)
1283                                                             {
1284                                                               if (((word >> 30) & 0x1) == 0)
1285                                                                 {
1286                                                                   /* 33222222222211111111110000000000
1287                                                                      10987654321098765432109876543210
1288                                                                      xxxxxxxxxx00010xxxxxx11000011100
1289                                                                      ldeorlb.  */
1290                                                                   return 1034;
1291                                                                 }
1292                                                               else
1293                                                                 {
1294                                                                   /* 33222222222211111111110000000000
1295                                                                      10987654321098765432109876543210
1296                                                                      xxxxxxxxxx00010xxxxxx11000011110
1297                                                                      ldeorlh.  */
1298                                                                   return 1037;
1299                                                                 }
1300                                                             }
1301                                                           else
1302                                                             {
1303                                                               /* 33222222222211111111110000000000
1304                                                                  10987654321098765432109876543210
1305                                                                  xxxxxxxxxx00010xxxxxx110000111x1
1306                                                                  ldeorl.  */
1307                                                               return 1040;
1308                                                             }
1309                                                         }
1310                                                       else
1311                                                         {
1312                                                           if (((word >> 31) & 0x1) == 0)
1313                                                             {
1314                                                               if (((word >> 30) & 0x1) == 0)
1315                                                                 {
1316                                                                   /* 33222222222211111111110000000000
1317                                                                      10987654321098765432109876543210
1318                                                                      xxxxxxxxxx00010xxxxxx11100011100
1319                                                                      ldeoralb.  */
1320                                                                   return 1035;
1321                                                                 }
1322                                                               else
1323                                                                 {
1324                                                                   /* 33222222222211111111110000000000
1325                                                                      10987654321098765432109876543210
1326                                                                      xxxxxxxxxx00010xxxxxx11100011110
1327                                                                      ldeoralh.  */
1328                                                                   return 1038;
1329                                                                 }
1330                                                             }
1331                                                           else
1332                                                             {
1333                                                               /* 33222222222211111111110000000000
1334                                                                  10987654321098765432109876543210
1335                                                                  xxxxxxxxxx00010xxxxxx111000111x1
1336                                                                  ldeoral.  */
1337                                                               return 1041;
1338                                                             }
1339                                                         }
1340                                                     }
1341                                                 }
1342                                               else
1343                                                 {
1344                                                   if (((word >> 22) & 0x1) == 0)
1345                                                     {
1346                                                       if (((word >> 23) & 0x1) == 0)
1347                                                         {
1348                                                           if (((word >> 31) & 0x1) == 0)
1349                                                             {
1350                                                               if (((word >> 30) & 0x1) == 0)
1351                                                                 {
1352                                                                   /* 33222222222211111111110000000000
1353                                                                      10987654321098765432109876543210
1354                                                                      xxxxxxxxxx00011xxxxxx10000011100
1355                                                                      ldumaxb.  */
1356                                                                   return 1078;
1357                                                                 }
1358                                                               else
1359                                                                 {
1360                                                                   /* 33222222222211111111110000000000
1361                                                                      10987654321098765432109876543210
1362                                                                      xxxxxxxxxx00011xxxxxx10000011110
1363                                                                      ldumaxh.  */
1364                                                                   return 1079;
1365                                                                 }
1366                                                             }
1367                                                           else
1368                                                             {
1369                                                               /* 33222222222211111111110000000000
1370                                                                  10987654321098765432109876543210
1371                                                                  xxxxxxxxxx00011xxxxxx100000111x1
1372                                                                  ldumax.  */
1373                                                               return 1080;
1374                                                             }
1375                                                         }
1376                                                       else
1377                                                         {
1378                                                           if (((word >> 31) & 0x1) == 0)
1379                                                             {
1380                                                               if (((word >> 30) & 0x1) == 0)
1381                                                                 {
1382                                                                   /* 33222222222211111111110000000000
1383                                                                      10987654321098765432109876543210
1384                                                                      xxxxxxxxxx00011xxxxxx10100011100
1385                                                                      ldumaxab.  */
1386                                                                   return 1081;
1387                                                                 }
1388                                                               else
1389                                                                 {
1390                                                                   /* 33222222222211111111110000000000
1391                                                                      10987654321098765432109876543210
1392                                                                      xxxxxxxxxx00011xxxxxx10100011110
1393                                                                      ldumaxah.  */
1394                                                                   return 1084;
1395                                                                 }
1396                                                             }
1397                                                           else
1398                                                             {
1399                                                               /* 33222222222211111111110000000000
1400                                                                  10987654321098765432109876543210
1401                                                                  xxxxxxxxxx00011xxxxxx101000111x1
1402                                                                  ldumaxa.  */
1403                                                               return 1087;
1404                                                             }
1405                                                         }
1406                                                     }
1407                                                   else
1408                                                     {
1409                                                       if (((word >> 23) & 0x1) == 0)
1410                                                         {
1411                                                           if (((word >> 31) & 0x1) == 0)
1412                                                             {
1413                                                               if (((word >> 30) & 0x1) == 0)
1414                                                                 {
1415                                                                   /* 33222222222211111111110000000000
1416                                                                      10987654321098765432109876543210
1417                                                                      xxxxxxxxxx00011xxxxxx11000011100
1418                                                                      ldumaxlb.  */
1419                                                                   return 1082;
1420                                                                 }
1421                                                               else
1422                                                                 {
1423                                                                   /* 33222222222211111111110000000000
1424                                                                      10987654321098765432109876543210
1425                                                                      xxxxxxxxxx00011xxxxxx11000011110
1426                                                                      ldumaxlh.  */
1427                                                                   return 1085;
1428                                                                 }
1429                                                             }
1430                                                           else
1431                                                             {
1432                                                               /* 33222222222211111111110000000000
1433                                                                  10987654321098765432109876543210
1434                                                                  xxxxxxxxxx00011xxxxxx110000111x1
1435                                                                  ldumaxl.  */
1436                                                               return 1088;
1437                                                             }
1438                                                         }
1439                                                       else
1440                                                         {
1441                                                           if (((word >> 31) & 0x1) == 0)
1442                                                             {
1443                                                               if (((word >> 30) & 0x1) == 0)
1444                                                                 {
1445                                                                   /* 33222222222211111111110000000000
1446                                                                      10987654321098765432109876543210
1447                                                                      xxxxxxxxxx00011xxxxxx11100011100
1448                                                                      ldumaxalb.  */
1449                                                                   return 1083;
1450                                                                 }
1451                                                               else
1452                                                                 {
1453                                                                   /* 33222222222211111111110000000000
1454                                                                      10987654321098765432109876543210
1455                                                                      xxxxxxxxxx00011xxxxxx11100011110
1456                                                                      ldumaxalh.  */
1457                                                                   return 1086;
1458                                                                 }
1459                                                             }
1460                                                           else
1461                                                             {
1462                                                               /* 33222222222211111111110000000000
1463                                                                  10987654321098765432109876543210
1464                                                                  xxxxxxxxxx00011xxxxxx111000111x1
1465                                                                  ldumaxal.  */
1466                                                               return 1089;
1467                                                             }
1468                                                         }
1469                                                     }
1470                                                 }
1471                                             }
1472                                         }
1473                                       else
1474                                         {
1475                                           if (((word >> 13) & 0x1) == 0)
1476                                             {
1477                                               if (((word >> 14) & 0x1) == 0)
1478                                                 {
1479                                                   if (((word >> 22) & 0x1) == 0)
1480                                                     {
1481                                                       if (((word >> 23) & 0x1) == 0)
1482                                                         {
1483                                                           if (((word >> 31) & 0x1) == 0)
1484                                                             {
1485                                                               if (((word >> 30) & 0x1) == 0)
1486                                                                 {
1487                                                                   /* 33222222222211111111110000000000
1488                                                                      10987654321098765432109876543210
1489                                                                      xxxxxxxxxx00100xxxxxx10000011100
1490                                                                      ldclrb.  */
1491                                                                   return 1018;
1492                                                                 }
1493                                                               else
1494                                                                 {
1495                                                                   /* 33222222222211111111110000000000
1496                                                                      10987654321098765432109876543210
1497                                                                      xxxxxxxxxx00100xxxxxx10000011110
1498                                                                      ldclrh.  */
1499                                                                   return 1019;
1500                                                                 }
1501                                                             }
1502                                                           else
1503                                                             {
1504                                                               /* 33222222222211111111110000000000
1505                                                                  10987654321098765432109876543210
1506                                                                  xxxxxxxxxx00100xxxxxx100000111x1
1507                                                                  ldclr.  */
1508                                                               return 1020;
1509                                                             }
1510                                                         }
1511                                                       else
1512                                                         {
1513                                                           if (((word >> 31) & 0x1) == 0)
1514                                                             {
1515                                                               if (((word >> 30) & 0x1) == 0)
1516                                                                 {
1517                                                                   /* 33222222222211111111110000000000
1518                                                                      10987654321098765432109876543210
1519                                                                      xxxxxxxxxx00100xxxxxx10100011100
1520                                                                      ldclrab.  */
1521                                                                   return 1021;
1522                                                                 }
1523                                                               else
1524                                                                 {
1525                                                                   /* 33222222222211111111110000000000
1526                                                                      10987654321098765432109876543210
1527                                                                      xxxxxxxxxx00100xxxxxx10100011110
1528                                                                      ldclrah.  */
1529                                                                   return 1024;
1530                                                                 }
1531                                                             }
1532                                                           else
1533                                                             {
1534                                                               /* 33222222222211111111110000000000
1535                                                                  10987654321098765432109876543210
1536                                                                  xxxxxxxxxx00100xxxxxx101000111x1
1537                                                                  ldclra.  */
1538                                                               return 1027;
1539                                                             }
1540                                                         }
1541                                                     }
1542                                                   else
1543                                                     {
1544                                                       if (((word >> 23) & 0x1) == 0)
1545                                                         {
1546                                                           if (((word >> 31) & 0x1) == 0)
1547                                                             {
1548                                                               if (((word >> 30) & 0x1) == 0)
1549                                                                 {
1550                                                                   /* 33222222222211111111110000000000
1551                                                                      10987654321098765432109876543210
1552                                                                      xxxxxxxxxx00100xxxxxx11000011100
1553                                                                      ldclrlb.  */
1554                                                                   return 1022;
1555                                                                 }
1556                                                               else
1557                                                                 {
1558                                                                   /* 33222222222211111111110000000000
1559                                                                      10987654321098765432109876543210
1560                                                                      xxxxxxxxxx00100xxxxxx11000011110
1561                                                                      ldclrlh.  */
1562                                                                   return 1025;
1563                                                                 }
1564                                                             }
1565                                                           else
1566                                                             {
1567                                                               /* 33222222222211111111110000000000
1568                                                                  10987654321098765432109876543210
1569                                                                  xxxxxxxxxx00100xxxxxx110000111x1
1570                                                                  ldclrl.  */
1571                                                               return 1028;
1572                                                             }
1573                                                         }
1574                                                       else
1575                                                         {
1576                                                           if (((word >> 31) & 0x1) == 0)
1577                                                             {
1578                                                               if (((word >> 30) & 0x1) == 0)
1579                                                                 {
1580                                                                   /* 33222222222211111111110000000000
1581                                                                      10987654321098765432109876543210
1582                                                                      xxxxxxxxxx00100xxxxxx11100011100
1583                                                                      ldclralb.  */
1584                                                                   return 1023;
1585                                                                 }
1586                                                               else
1587                                                                 {
1588                                                                   /* 33222222222211111111110000000000
1589                                                                      10987654321098765432109876543210
1590                                                                      xxxxxxxxxx00100xxxxxx11100011110
1591                                                                      ldclralh.  */
1592                                                                   return 1026;
1593                                                                 }
1594                                                             }
1595                                                           else
1596                                                             {
1597                                                               /* 33222222222211111111110000000000
1598                                                                  10987654321098765432109876543210
1599                                                                  xxxxxxxxxx00100xxxxxx111000111x1
1600                                                                  ldclral.  */
1601                                                               return 1029;
1602                                                             }
1603                                                         }
1604                                                     }
1605                                                 }
1606                                               else
1607                                                 {
1608                                                   if (((word >> 22) & 0x1) == 0)
1609                                                     {
1610                                                       if (((word >> 23) & 0x1) == 0)
1611                                                         {
1612                                                           if (((word >> 31) & 0x1) == 0)
1613                                                             {
1614                                                               if (((word >> 30) & 0x1) == 0)
1615                                                                 {
1616                                                                   /* 33222222222211111111110000000000
1617                                                                      10987654321098765432109876543210
1618                                                                      xxxxxxxxxx00101xxxxxx10000011100
1619                                                                      ldsminb.  */
1620                                                                   return 1066;
1621                                                                 }
1622                                                               else
1623                                                                 {
1624                                                                   /* 33222222222211111111110000000000
1625                                                                      10987654321098765432109876543210
1626                                                                      xxxxxxxxxx00101xxxxxx10000011110
1627                                                                      ldsminh.  */
1628                                                                   return 1067;
1629                                                                 }
1630                                                             }
1631                                                           else
1632                                                             {
1633                                                               /* 33222222222211111111110000000000
1634                                                                  10987654321098765432109876543210
1635                                                                  xxxxxxxxxx00101xxxxxx100000111x1
1636                                                                  ldsmin.  */
1637                                                               return 1068;
1638                                                             }
1639                                                         }
1640                                                       else
1641                                                         {
1642                                                           if (((word >> 31) & 0x1) == 0)
1643                                                             {
1644                                                               if (((word >> 30) & 0x1) == 0)
1645                                                                 {
1646                                                                   /* 33222222222211111111110000000000
1647                                                                      10987654321098765432109876543210
1648                                                                      xxxxxxxxxx00101xxxxxx10100011100
1649                                                                      ldsminab.  */
1650                                                                   return 1069;
1651                                                                 }
1652                                                               else
1653                                                                 {
1654                                                                   /* 33222222222211111111110000000000
1655                                                                      10987654321098765432109876543210
1656                                                                      xxxxxxxxxx00101xxxxxx10100011110
1657                                                                      ldsminah.  */
1658                                                                   return 1072;
1659                                                                 }
1660                                                             }
1661                                                           else
1662                                                             {
1663                                                               /* 33222222222211111111110000000000
1664                                                                  10987654321098765432109876543210
1665                                                                  xxxxxxxxxx00101xxxxxx101000111x1
1666                                                                  ldsmina.  */
1667                                                               return 1075;
1668                                                             }
1669                                                         }
1670                                                     }
1671                                                   else
1672                                                     {
1673                                                       if (((word >> 23) & 0x1) == 0)
1674                                                         {
1675                                                           if (((word >> 31) & 0x1) == 0)
1676                                                             {
1677                                                               if (((word >> 30) & 0x1) == 0)
1678                                                                 {
1679                                                                   /* 33222222222211111111110000000000
1680                                                                      10987654321098765432109876543210
1681                                                                      xxxxxxxxxx00101xxxxxx11000011100
1682                                                                      ldsminlb.  */
1683                                                                   return 1070;
1684                                                                 }
1685                                                               else
1686                                                                 {
1687                                                                   /* 33222222222211111111110000000000
1688                                                                      10987654321098765432109876543210
1689                                                                      xxxxxxxxxx00101xxxxxx11000011110
1690                                                                      ldsminlh.  */
1691                                                                   return 1073;
1692                                                                 }
1693                                                             }
1694                                                           else
1695                                                             {
1696                                                               /* 33222222222211111111110000000000
1697                                                                  10987654321098765432109876543210
1698                                                                  xxxxxxxxxx00101xxxxxx110000111x1
1699                                                                  ldsminl.  */
1700                                                               return 1076;
1701                                                             }
1702                                                         }
1703                                                       else
1704                                                         {
1705                                                           if (((word >> 31) & 0x1) == 0)
1706                                                             {
1707                                                               if (((word >> 30) & 0x1) == 0)
1708                                                                 {
1709                                                                   /* 33222222222211111111110000000000
1710                                                                      10987654321098765432109876543210
1711                                                                      xxxxxxxxxx00101xxxxxx11100011100
1712                                                                      ldsminalb.  */
1713                                                                   return 1071;
1714                                                                 }
1715                                                               else
1716                                                                 {
1717                                                                   /* 33222222222211111111110000000000
1718                                                                      10987654321098765432109876543210
1719                                                                      xxxxxxxxxx00101xxxxxx11100011110
1720                                                                      ldsminalh.  */
1721                                                                   return 1074;
1722                                                                 }
1723                                                             }
1724                                                           else
1725                                                             {
1726                                                               /* 33222222222211111111110000000000
1727                                                                  10987654321098765432109876543210
1728                                                                  xxxxxxxxxx00101xxxxxx111000111x1
1729                                                                  ldsminal.  */
1730                                                               return 1077;
1731                                                             }
1732                                                         }
1733                                                     }
1734                                                 }
1735                                             }
1736                                           else
1737                                             {
1738                                               if (((word >> 14) & 0x1) == 0)
1739                                                 {
1740                                                   if (((word >> 22) & 0x1) == 0)
1741                                                     {
1742                                                       if (((word >> 23) & 0x1) == 0)
1743                                                         {
1744                                                           if (((word >> 31) & 0x1) == 0)
1745                                                             {
1746                                                               if (((word >> 30) & 0x1) == 0)
1747                                                                 {
1748                                                                   /* 33222222222211111111110000000000
1749                                                                      10987654321098765432109876543210
1750                                                                      xxxxxxxxxx00110xxxxxx10000011100
1751                                                                      ldsetb.  */
1752                                                                   return 1042;
1753                                                                 }
1754                                                               else
1755                                                                 {
1756                                                                   /* 33222222222211111111110000000000
1757                                                                      10987654321098765432109876543210
1758                                                                      xxxxxxxxxx00110xxxxxx10000011110
1759                                                                      ldseth.  */
1760                                                                   return 1043;
1761                                                                 }
1762                                                             }
1763                                                           else
1764                                                             {
1765                                                               /* 33222222222211111111110000000000
1766                                                                  10987654321098765432109876543210
1767                                                                  xxxxxxxxxx00110xxxxxx100000111x1
1768                                                                  ldset.  */
1769                                                               return 1044;
1770                                                             }
1771                                                         }
1772                                                       else
1773                                                         {
1774                                                           if (((word >> 31) & 0x1) == 0)
1775                                                             {
1776                                                               if (((word >> 30) & 0x1) == 0)
1777                                                                 {
1778                                                                   /* 33222222222211111111110000000000
1779                                                                      10987654321098765432109876543210
1780                                                                      xxxxxxxxxx00110xxxxxx10100011100
1781                                                                      ldsetab.  */
1782                                                                   return 1045;
1783                                                                 }
1784                                                               else
1785                                                                 {
1786                                                                   /* 33222222222211111111110000000000
1787                                                                      10987654321098765432109876543210
1788                                                                      xxxxxxxxxx00110xxxxxx10100011110
1789                                                                      ldsetah.  */
1790                                                                   return 1048;
1791                                                                 }
1792                                                             }
1793                                                           else
1794                                                             {
1795                                                               /* 33222222222211111111110000000000
1796                                                                  10987654321098765432109876543210
1797                                                                  xxxxxxxxxx00110xxxxxx101000111x1
1798                                                                  ldseta.  */
1799                                                               return 1051;
1800                                                             }
1801                                                         }
1802                                                     }
1803                                                   else
1804                                                     {
1805                                                       if (((word >> 23) & 0x1) == 0)
1806                                                         {
1807                                                           if (((word >> 31) & 0x1) == 0)
1808                                                             {
1809                                                               if (((word >> 30) & 0x1) == 0)
1810                                                                 {
1811                                                                   /* 33222222222211111111110000000000
1812                                                                      10987654321098765432109876543210
1813                                                                      xxxxxxxxxx00110xxxxxx11000011100
1814                                                                      ldsetlb.  */
1815                                                                   return 1046;
1816                                                                 }
1817                                                               else
1818                                                                 {
1819                                                                   /* 33222222222211111111110000000000
1820                                                                      10987654321098765432109876543210
1821                                                                      xxxxxxxxxx00110xxxxxx11000011110
1822                                                                      ldsetlh.  */
1823                                                                   return 1049;
1824                                                                 }
1825                                                             }
1826                                                           else
1827                                                             {
1828                                                               /* 33222222222211111111110000000000
1829                                                                  10987654321098765432109876543210
1830                                                                  xxxxxxxxxx00110xxxxxx110000111x1
1831                                                                  ldsetl.  */
1832                                                               return 1052;
1833                                                             }
1834                                                         }
1835                                                       else
1836                                                         {
1837                                                           if (((word >> 31) & 0x1) == 0)
1838                                                             {
1839                                                               if (((word >> 30) & 0x1) == 0)
1840                                                                 {
1841                                                                   /* 33222222222211111111110000000000
1842                                                                      10987654321098765432109876543210
1843                                                                      xxxxxxxxxx00110xxxxxx11100011100
1844                                                                      ldsetalb.  */
1845                                                                   return 1047;
1846                                                                 }
1847                                                               else
1848                                                                 {
1849                                                                   /* 33222222222211111111110000000000
1850                                                                      10987654321098765432109876543210
1851                                                                      xxxxxxxxxx00110xxxxxx11100011110
1852                                                                      ldsetalh.  */
1853                                                                   return 1050;
1854                                                                 }
1855                                                             }
1856                                                           else
1857                                                             {
1858                                                               /* 33222222222211111111110000000000
1859                                                                  10987654321098765432109876543210
1860                                                                  xxxxxxxxxx00110xxxxxx111000111x1
1861                                                                  ldsetal.  */
1862                                                               return 1053;
1863                                                             }
1864                                                         }
1865                                                     }
1866                                                 }
1867                                               else
1868                                                 {
1869                                                   if (((word >> 22) & 0x1) == 0)
1870                                                     {
1871                                                       if (((word >> 23) & 0x1) == 0)
1872                                                         {
1873                                                           if (((word >> 31) & 0x1) == 0)
1874                                                             {
1875                                                               if (((word >> 30) & 0x1) == 0)
1876                                                                 {
1877                                                                   /* 33222222222211111111110000000000
1878                                                                      10987654321098765432109876543210
1879                                                                      xxxxxxxxxx00111xxxxxx10000011100
1880                                                                      lduminb.  */
1881                                                                   return 1090;
1882                                                                 }
1883                                                               else
1884                                                                 {
1885                                                                   /* 33222222222211111111110000000000
1886                                                                      10987654321098765432109876543210
1887                                                                      xxxxxxxxxx00111xxxxxx10000011110
1888                                                                      lduminh.  */
1889                                                                   return 1091;
1890                                                                 }
1891                                                             }
1892                                                           else
1893                                                             {
1894                                                               /* 33222222222211111111110000000000
1895                                                                  10987654321098765432109876543210
1896                                                                  xxxxxxxxxx00111xxxxxx100000111x1
1897                                                                  ldumin.  */
1898                                                               return 1092;
1899                                                             }
1900                                                         }
1901                                                       else
1902                                                         {
1903                                                           if (((word >> 31) & 0x1) == 0)
1904                                                             {
1905                                                               if (((word >> 30) & 0x1) == 0)
1906                                                                 {
1907                                                                   /* 33222222222211111111110000000000
1908                                                                      10987654321098765432109876543210
1909                                                                      xxxxxxxxxx00111xxxxxx10100011100
1910                                                                      lduminab.  */
1911                                                                   return 1093;
1912                                                                 }
1913                                                               else
1914                                                                 {
1915                                                                   /* 33222222222211111111110000000000
1916                                                                      10987654321098765432109876543210
1917                                                                      xxxxxxxxxx00111xxxxxx10100011110
1918                                                                      lduminah.  */
1919                                                                   return 1096;
1920                                                                 }
1921                                                             }
1922                                                           else
1923                                                             {
1924                                                               /* 33222222222211111111110000000000
1925                                                                  10987654321098765432109876543210
1926                                                                  xxxxxxxxxx00111xxxxxx101000111x1
1927                                                                  ldumina.  */
1928                                                               return 1099;
1929                                                             }
1930                                                         }
1931                                                     }
1932                                                   else
1933                                                     {
1934                                                       if (((word >> 23) & 0x1) == 0)
1935                                                         {
1936                                                           if (((word >> 31) & 0x1) == 0)
1937                                                             {
1938                                                               if (((word >> 30) & 0x1) == 0)
1939                                                                 {
1940                                                                   /* 33222222222211111111110000000000
1941                                                                      10987654321098765432109876543210
1942                                                                      xxxxxxxxxx00111xxxxxx11000011100
1943                                                                      lduminlb.  */
1944                                                                   return 1094;
1945                                                                 }
1946                                                               else
1947                                                                 {
1948                                                                   /* 33222222222211111111110000000000
1949                                                                      10987654321098765432109876543210
1950                                                                      xxxxxxxxxx00111xxxxxx11000011110
1951                                                                      lduminlh.  */
1952                                                                   return 1097;
1953                                                                 }
1954                                                             }
1955                                                           else
1956                                                             {
1957                                                               /* 33222222222211111111110000000000
1958                                                                  10987654321098765432109876543210
1959                                                                  xxxxxxxxxx00111xxxxxx110000111x1
1960                                                                  lduminl.  */
1961                                                               return 1100;
1962                                                             }
1963                                                         }
1964                                                       else
1965                                                         {
1966                                                           if (((word >> 31) & 0x1) == 0)
1967                                                             {
1968                                                               if (((word >> 30) & 0x1) == 0)
1969                                                                 {
1970                                                                   /* 33222222222211111111110000000000
1971                                                                      10987654321098765432109876543210
1972                                                                      xxxxxxxxxx00111xxxxxx11100011100
1973                                                                      lduminalb.  */
1974                                                                   return 1095;
1975                                                                 }
1976                                                               else
1977                                                                 {
1978                                                                   /* 33222222222211111111110000000000
1979                                                                      10987654321098765432109876543210
1980                                                                      xxxxxxxxxx00111xxxxxx11100011110
1981                                                                      lduminalh.  */
1982                                                                   return 1098;
1983                                                                 }
1984                                                             }
1985                                                           else
1986                                                             {
1987                                                               /* 33222222222211111111110000000000
1988                                                                  10987654321098765432109876543210
1989                                                                  xxxxxxxxxx00111xxxxxx111000111x1
1990                                                                  lduminal.  */
1991                                                               return 1101;
1992                                                             }
1993                                                         }
1994                                                     }
1995                                                 }
1996                                             }
1997                                         }
1998                                     }
1999                                 }
2000                               else
2001                                 {
2002                                   if (((word >> 21) & 0x1) == 0)
2003                                     {
2004                                       if (((word >> 23) & 0x1) == 0)
2005                                         {
2006                                           if (((word >> 22) & 0x1) == 0)
2007                                             {
2008                                               if (((word >> 31) & 0x1) == 0)
2009                                                 {
2010                                                   if (((word >> 30) & 0x1) == 0)
2011                                                     {
2012                                                       /* 33222222222211111111110000000000
2013                                                          10987654321098765432109876543210
2014                                                          xxxxxxxxxx01xxxxxxxxx00000011100
2015                                                          sttrb.  */
2016                                                       return 887;
2017                                                     }
2018                                                   else
2019                                                     {
2020                                                       /* 33222222222211111111110000000000
2021                                                          10987654321098765432109876543210
2022                                                          xxxxxxxxxx01xxxxxxxxx00000011110
2023                                                          sttrh.  */
2024                                                       return 890;
2025                                                     }
2026                                                 }
2027                                               else
2028                                                 {
2029                                                   /* 33222222222211111111110000000000
2030                                                      10987654321098765432109876543210
2031                                                      xxxxxxxxxx01xxxxxxxxx000000111x1
2032                                                      sttr.  */
2033                                                   return 893;
2034                                                 }
2035                                             }
2036                                           else
2037                                             {
2038                                               if (((word >> 31) & 0x1) == 0)
2039                                                 {
2040                                                   if (((word >> 30) & 0x1) == 0)
2041                                                     {
2042                                                       /* 33222222222211111111110000000000
2043                                                          10987654321098765432109876543210
2044                                                          xxxxxxxxxx01xxxxxxxxx01000011100
2045                                                          ldtrb.  */
2046                                                       return 888;
2047                                                     }
2048                                                   else
2049                                                     {
2050                                                       /* 33222222222211111111110000000000
2051                                                          10987654321098765432109876543210
2052                                                          xxxxxxxxxx01xxxxxxxxx01000011110
2053                                                          ldtrh.  */
2054                                                       return 891;
2055                                                     }
2056                                                 }
2057                                               else
2058                                                 {
2059                                                   /* 33222222222211111111110000000000
2060                                                      10987654321098765432109876543210
2061                                                      xxxxxxxxxx01xxxxxxxxx010000111x1
2062                                                      ldtr.  */
2063                                                   return 894;
2064                                                 }
2065                                             }
2066                                         }
2067                                       else
2068                                         {
2069                                           if (((word >> 30) & 0x1) == 0)
2070                                             {
2071                                               if (((word >> 31) & 0x1) == 0)
2072                                                 {
2073                                                   /* 33222222222211111111110000000000
2074                                                      10987654321098765432109876543210
2075                                                      xxxxxxxxxx01xxxxxxxxx0x100011100
2076                                                      ldtrsb.  */
2077                                                   return 889;
2078                                                 }
2079                                               else
2080                                                 {
2081                                                   /* 33222222222211111111110000000000
2082                                                      10987654321098765432109876543210
2083                                                      xxxxxxxxxx01xxxxxxxxx0x100011101
2084                                                      ldtrsw.  */
2085                                                   return 895;
2086                                                 }
2087                                             }
2088                                           else
2089                                             {
2090                                               /* 33222222222211111111110000000000
2091                                                  10987654321098765432109876543210
2092                                                  xxxxxxxxxx01xxxxxxxxx0x10001111x
2093                                                  ldtrsh.  */
2094                                               return 892;
2095                                             }
2096                                         }
2097                                     }
2098                                   else
2099                                     {
2100                                       if (((word >> 23) & 0x1) == 0)
2101                                         {
2102                                           if (((word >> 22) & 0x1) == 0)
2103                                             {
2104                                               if (((word >> 31) & 0x1) == 0)
2105                                                 {
2106                                                   if (((word >> 30) & 0x1) == 0)
2107                                                     {
2108                                                       /* 33222222222211111111110000000000
2109                                                          10987654321098765432109876543210
2110                                                          xxxxxxxxxx01xxxxxxxxx10000011100
2111                                                          strb.  */
2112                                                       return 875;
2113                                                     }
2114                                                   else
2115                                                     {
2116                                                       /* 33222222222211111111110000000000
2117                                                          10987654321098765432109876543210
2118                                                          xxxxxxxxxx01xxxxxxxxx10000011110
2119                                                          strh.  */
2120                                                       return 880;
2121                                                     }
2122                                                 }
2123                                               else
2124                                                 {
2125                                                   /* 33222222222211111111110000000000
2126                                                      10987654321098765432109876543210
2127                                                      xxxxxxxxxx01xxxxxxxxx100000111x1
2128                                                      str.  */
2129                                                   return 883;
2130                                                 }
2131                                             }
2132                                           else
2133                                             {
2134                                               if (((word >> 31) & 0x1) == 0)
2135                                                 {
2136                                                   if (((word >> 30) & 0x1) == 0)
2137                                                     {
2138                                                       /* 33222222222211111111110000000000
2139                                                          10987654321098765432109876543210
2140                                                          xxxxxxxxxx01xxxxxxxxx11000011100
2141                                                          ldrb.  */
2142                                                       return 876;
2143                                                     }
2144                                                   else
2145                                                     {
2146                                                       /* 33222222222211111111110000000000
2147                                                          10987654321098765432109876543210
2148                                                          xxxxxxxxxx01xxxxxxxxx11000011110
2149                                                          ldrh.  */
2150                                                       return 881;
2151                                                     }
2152                                                 }
2153                                               else
2154                                                 {
2155                                                   /* 33222222222211111111110000000000
2156                                                      10987654321098765432109876543210
2157                                                      xxxxxxxxxx01xxxxxxxxx110000111x1
2158                                                      ldr.  */
2159                                                   return 884;
2160                                                 }
2161                                             }
2162                                         }
2163                                       else
2164                                         {
2165                                           if (((word >> 30) & 0x1) == 0)
2166                                             {
2167                                               if (((word >> 31) & 0x1) == 0)
2168                                                 {
2169                                                   /* 33222222222211111111110000000000
2170                                                      10987654321098765432109876543210
2171                                                      xxxxxxxxxx01xxxxxxxxx1x100011100
2172                                                      ldrsb.  */
2173                                                   return 877;
2174                                                 }
2175                                               else
2176                                                 {
2177                                                   /* 33222222222211111111110000000000
2178                                                      10987654321098765432109876543210
2179                                                      xxxxxxxxxx01xxxxxxxxx1x100011101
2180                                                      ldrsw.  */
2181                                                   return 885;
2182                                                 }
2183                                             }
2184                                           else
2185                                             {
2186                                               if (((word >> 31) & 0x1) == 0)
2187                                                 {
2188                                                   /* 33222222222211111111110000000000
2189                                                      10987654321098765432109876543210
2190                                                      xxxxxxxxxx01xxxxxxxxx1x100011110
2191                                                      ldrsh.  */
2192                                                   return 882;
2193                                                 }
2194                                               else
2195                                                 {
2196                                                   /* 33222222222211111111110000000000
2197                                                      10987654321098765432109876543210
2198                                                      xxxxxxxxxx01xxxxxxxxx1x100011111
2199                                                      prfm.  */
2200                                                   return 886;
2201                                                 }
2202                                             }
2203                                         }
2204                                     }
2205                                 }
2206                             }
2207                           else
2208                             {
2209                               if (((word >> 21) & 0x1) == 0)
2210                                 {
2211                                   if (((word >> 23) & 0x1) == 0)
2212                                     {
2213                                       if (((word >> 22) & 0x1) == 0)
2214                                         {
2215                                           if (((word >> 31) & 0x1) == 0)
2216                                             {
2217                                               if (((word >> 30) & 0x1) == 0)
2218                                                 {
2219                                                   /* 33222222222211111111110000000000
2220                                                      10987654321098765432109876543210
2221                                                      xxxxxxxxxx1xxxxxxxxxx00000011100
2222                                                      strb.  */
2223                                                   return 852;
2224                                                 }
2225                                               else
2226                                                 {
2227                                                   /* 33222222222211111111110000000000
2228                                                      10987654321098765432109876543210
2229                                                      xxxxxxxxxx1xxxxxxxxxx00000011110
2230                                                      strh.  */
2231                                                   return 857;
2232                                                 }
2233                                             }
2234                                           else
2235                                             {
2236                                               /* 33222222222211111111110000000000
2237                                                  10987654321098765432109876543210
2238                                                  xxxxxxxxxx1xxxxxxxxxx000000111x1
2239                                                  str.  */
2240                                               return 860;
2241                                             }
2242                                         }
2243                                       else
2244                                         {
2245                                           if (((word >> 31) & 0x1) == 0)
2246                                             {
2247                                               if (((word >> 30) & 0x1) == 0)
2248                                                 {
2249                                                   /* 33222222222211111111110000000000
2250                                                      10987654321098765432109876543210
2251                                                      xxxxxxxxxx1xxxxxxxxxx01000011100
2252                                                      ldrb.  */
2253                                                   return 853;
2254                                                 }
2255                                               else
2256                                                 {
2257                                                   /* 33222222222211111111110000000000
2258                                                      10987654321098765432109876543210
2259                                                      xxxxxxxxxx1xxxxxxxxxx01000011110
2260                                                      ldrh.  */
2261                                                   return 858;
2262                                                 }
2263                                             }
2264                                           else
2265                                             {
2266                                               /* 33222222222211111111110000000000
2267                                                  10987654321098765432109876543210
2268                                                  xxxxxxxxxx1xxxxxxxxxx010000111x1
2269                                                  ldr.  */
2270                                               return 861;
2271                                             }
2272                                         }
2273                                     }
2274                                   else
2275                                     {
2276                                       if (((word >> 30) & 0x1) == 0)
2277                                         {
2278                                           if (((word >> 31) & 0x1) == 0)
2279                                             {
2280                                               /* 33222222222211111111110000000000
2281                                                  10987654321098765432109876543210
2282                                                  xxxxxxxxxx1xxxxxxxxxx0x100011100
2283                                                  ldrsb.  */
2284                                               return 854;
2285                                             }
2286                                           else
2287                                             {
2288                                               /* 33222222222211111111110000000000
2289                                                  10987654321098765432109876543210
2290                                                  xxxxxxxxxx1xxxxxxxxxx0x100011101
2291                                                  ldrsw.  */
2292                                               return 862;
2293                                             }
2294                                         }
2295                                       else
2296                                         {
2297                                           /* 33222222222211111111110000000000
2298                                              10987654321098765432109876543210
2299                                              xxxxxxxxxx1xxxxxxxxxx0x10001111x
2300                                              ldrsh.  */
2301                                           return 859;
2302                                         }
2303                                     }
2304                                 }
2305                               else
2306                                 {
2307                                   if (((word >> 23) & 0x1) == 0)
2308                                     {
2309                                       /* 33222222222211111111110000000000
2310                                          10987654321098765432109876543210
2311                                          xxxxxxxxxx1xxxxxxxxxx1x0000111xx
2312                                          ldraa.  */
2313                                       return 908;
2314                                     }
2315                                   else
2316                                     {
2317                                       /* 33222222222211111111110000000000
2318                                          10987654321098765432109876543210
2319                                          xxxxxxxxxx1xxxxxxxxxx1x1000111xx
2320                                          ldrab.  */
2321                                       return 909;
2322                                     }
2323                                 }
2324                             }
2325                         }
2326                     }
2327                   else
2328                     {
2329                       if (((word >> 23) & 0x1) == 0)
2330                         {
2331                           if (((word >> 22) & 0x1) == 0)
2332                             {
2333                               if (((word >> 31) & 0x1) == 0)
2334                                 {
2335                                   if (((word >> 30) & 0x1) == 0)
2336                                     {
2337                                       /* 33222222222211111111110000000000
2338                                          10987654321098765432109876543210
2339                                          xxxxxxxxxxxxxxxxxxxxxx0010011x00
2340                                          strb.  */
2341                                       return 863;
2342                                     }
2343                                   else
2344                                     {
2345                                       /* 33222222222211111111110000000000
2346                                          10987654321098765432109876543210
2347                                          xxxxxxxxxxxxxxxxxxxxxx0010011x10
2348                                          strh.  */
2349                                       return 868;
2350                                     }
2351                                 }
2352                               else
2353                                 {
2354                                   /* 33222222222211111111110000000000
2355                                      10987654321098765432109876543210
2356                                      xxxxxxxxxxxxxxxxxxxxxx0010011xx1
2357                                      str.  */
2358                                   return 871;
2359                                 }
2360                             }
2361                           else
2362                             {
2363                               if (((word >> 31) & 0x1) == 0)
2364                                 {
2365                                   if (((word >> 30) & 0x1) == 0)
2366                                     {
2367                                       /* 33222222222211111111110000000000
2368                                          10987654321098765432109876543210
2369                                          xxxxxxxxxxxxxxxxxxxxxx1010011x00
2370                                          ldrb.  */
2371                                       return 864;
2372                                     }
2373                                   else
2374                                     {
2375                                       /* 33222222222211111111110000000000
2376                                          10987654321098765432109876543210
2377                                          xxxxxxxxxxxxxxxxxxxxxx1010011x10
2378                                          ldrh.  */
2379                                       return 869;
2380                                     }
2381                                 }
2382                               else
2383                                 {
2384                                   /* 33222222222211111111110000000000
2385                                      10987654321098765432109876543210
2386                                      xxxxxxxxxxxxxxxxxxxxxx1010011xx1
2387                                      ldr.  */
2388                                   return 872;
2389                                 }
2390                             }
2391                         }
2392                       else
2393                         {
2394                           if (((word >> 30) & 0x1) == 0)
2395                             {
2396                               if (((word >> 31) & 0x1) == 0)
2397                                 {
2398                                   /* 33222222222211111111110000000000
2399                                      10987654321098765432109876543210
2400                                      xxxxxxxxxxxxxxxxxxxxxxx110011x00
2401                                      ldrsb.  */
2402                                   return 865;
2403                                 }
2404                               else
2405                                 {
2406                                   /* 33222222222211111111110000000000
2407                                      10987654321098765432109876543210
2408                                      xxxxxxxxxxxxxxxxxxxxxxx110011x01
2409                                      ldrsw.  */
2410                                   return 873;
2411                                 }
2412                             }
2413                           else
2414                             {
2415                               if (((word >> 31) & 0x1) == 0)
2416                                 {
2417                                   /* 33222222222211111111110000000000
2418                                      10987654321098765432109876543210
2419                                      xxxxxxxxxxxxxxxxxxxxxxx110011x10
2420                                      ldrsh.  */
2421                                   return 870;
2422                                 }
2423                               else
2424                                 {
2425                                   /* 33222222222211111111110000000000
2426                                      10987654321098765432109876543210
2427                                      xxxxxxxxxxxxxxxxxxxxxxx110011x11
2428                                      prfm.  */
2429                                   return 874;
2430                                 }
2431                             }
2432                         }
2433                     }
2434                 }
2435             }
2436         }
2437       else
2438         {
2439           if (((word >> 24) & 0x1) == 0)
2440             {
2441               if (((word >> 27) & 0x1) == 0)
2442                 {
2443                   if (((word >> 23) & 0x1) == 0)
2444                     {
2445                       if (((word >> 29) & 0x1) == 0)
2446                         {
2447                           if (((word >> 30) & 0x1) == 0)
2448                             {
2449                               /* 33222222222211111111110000000000
2450                                  10987654321098765432109876543210
2451                                  xxxxxxxxxxxxxxxxxxxxxxx00100x00x
2452                                  and.  */
2453                               return 959;
2454                             }
2455                           else
2456                             {
2457                               /* 33222222222211111111110000000000
2458                                  10987654321098765432109876543210
2459                                  xxxxxxxxxxxxxxxxxxxxxxx00100x01x
2460                                  eor.  */
2461                               return 963;
2462                             }
2463                         }
2464                       else
2465                         {
2466                           if (((word >> 30) & 0x1) == 0)
2467                             {
2468                               /* 33222222222211111111110000000000
2469                                  10987654321098765432109876543210
2470                                  xxxxxxxxxxxxxxxxxxxxxxx00100x10x
2471                                  orr.  */
2472                               return 961;
2473                             }
2474                           else
2475                             {
2476                               /* 33222222222211111111110000000000
2477                                  10987654321098765432109876543210
2478                                  xxxxxxxxxxxxxxxxxxxxxxx00100x11x
2479                                  ands.  */
2480                               return 964;
2481                             }
2482                         }
2483                     }
2484                   else
2485                     {
2486                       if (((word >> 29) & 0x1) == 0)
2487                         {
2488                           if (((word >> 30) & 0x1) == 0)
2489                             {
2490                               /* 33222222222211111111110000000000
2491                                  10987654321098765432109876543210
2492                                  xxxxxxxxxxxxxxxxxxxxxxx10100x00x
2493                                  movn.  */
2494                               return 1150;
2495                             }
2496                           else
2497                             {
2498                               /* 33222222222211111111110000000000
2499                                  10987654321098765432109876543210
2500                                  xxxxxxxxxxxxxxxxxxxxxxx10100x01x
2501                                  movz.  */
2502                               return 1152;
2503                             }
2504                         }
2505                       else
2506                         {
2507                           /* 33222222222211111111110000000000
2508                              10987654321098765432109876543210
2509                              xxxxxxxxxxxxxxxxxxxxxxx10100x1xx
2510                              movk.  */
2511                           return 1154;
2512                         }
2513                     }
2514                 }
2515               else
2516                 {
2517                   if (((word >> 21) & 0x1) == 0)
2518                     {
2519                       if (((word >> 28) & 0x1) == 0)
2520                         {
2521                           if (((word >> 29) & 0x1) == 0)
2522                             {
2523                               if (((word >> 30) & 0x1) == 0)
2524                                 {
2525                                   /* 33222222222211111111110000000000
2526                                      10987654321098765432109876543210
2527                                      xxxxxxxxxxxxxxxxxxxxx0xx0101000x
2528                                      and.  */
2529                                   return 966;
2530                                 }
2531                               else
2532                                 {
2533                                   /* 33222222222211111111110000000000
2534                                      10987654321098765432109876543210
2535                                      xxxxxxxxxxxxxxxxxxxxx0xx0101001x
2536                                      eor.  */
2537                                   return 973;
2538                                 }
2539                             }
2540                           else
2541                             {
2542                               if (((word >> 30) & 0x1) == 0)
2543                                 {
2544                                   /* 33222222222211111111110000000000
2545                                      10987654321098765432109876543210
2546                                      xxxxxxxxxxxxxxxxxxxxx0xx0101010x
2547                                      orr.  */
2548                                   return 968;
2549                                 }
2550                               else
2551                                 {
2552                                   /* 33222222222211111111110000000000
2553                                      10987654321098765432109876543210
2554                                      xxxxxxxxxxxxxxxxxxxxx0xx0101011x
2555                                      ands.  */
2556                                   return 975;
2557                                 }
2558                             }
2559                         }
2560                       else
2561                         {
2562                           if (((word >> 10) & 0x1) == 0)
2563                             {
2564                               if (((word >> 11) & 0x1) == 0)
2565                                 {
2566                                   if (((word >> 22) & 0x1) == 0)
2567                                     {
2568                                       if (((word >> 23) & 0x1) == 0)
2569                                         {
2570                                           if (((word >> 29) & 0x1) == 0)
2571                                             {
2572                                               if (((word >> 30) & 0x1) == 0)
2573                                                 {
2574                                                   /* 33222222222211111111110000000000
2575                                                      10987654321098765432109876543210
2576                                                      xxxxxxxxxx00xxxxxxxxx0000101100x
2577                                                      adc.  */
2578                                                   return 0;
2579                                                 }
2580                                               else
2581                                                 {
2582                                                   /* 33222222222211111111110000000000
2583                                                      10987654321098765432109876543210
2584                                                      xxxxxxxxxx00xxxxxxxxx0000101101x
2585                                                      sbc.  */
2586                                                   return 2;
2587                                                 }
2588                                             }
2589                                           else
2590                                             {
2591                                               if (((word >> 30) & 0x1) == 0)
2592                                                 {
2593                                                   /* 33222222222211111111110000000000
2594                                                      10987654321098765432109876543210
2595                                                      xxxxxxxxxx00xxxxxxxxx0000101110x
2596                                                      adcs.  */
2597                                                   return 1;
2598                                                 }
2599                                               else
2600                                                 {
2601                                                   /* 33222222222211111111110000000000
2602                                                      10987654321098765432109876543210
2603                                                      xxxxxxxxxx00xxxxxxxxx0000101111x
2604                                                      sbcs.  */
2605                                                   return 4;
2606                                                 }
2607                                             }
2608                                         }
2609                                       else
2610                                         {
2611                                           if (((word >> 30) & 0x1) == 0)
2612                                             {
2613                                               /* 33222222222211111111110000000000
2614                                                  10987654321098765432109876543210
2615                                                  xxxxxxxxxx00xxxxxxxxx00101011x0x
2616                                                  csel.  */
2617                                               return 656;
2618                                             }
2619                                           else
2620                                             {
2621                                               /* 33222222222211111111110000000000
2622                                                  10987654321098765432109876543210
2623                                                  xxxxxxxxxx00xxxxxxxxx00101011x1x
2624                                                  csinv.  */
2625                                               return 660;
2626                                             }
2627                                         }
2628                                     }
2629                                   else
2630                                     {
2631                                       if (((word >> 23) & 0x1) == 0)
2632                                         {
2633                                           if (((word >> 30) & 0x1) == 0)
2634                                             {
2635                                               /* 33222222222211111111110000000000
2636                                                  10987654321098765432109876543210
2637                                                  xxxxxxxxxx00xxxxxxxxx01001011x0x
2638                                                  ccmn.  */
2639                                               return 654;
2640                                             }
2641                                           else
2642                                             {
2643                                               /* 33222222222211111111110000000000
2644                                                  10987654321098765432109876543210
2645                                                  xxxxxxxxxx00xxxxxxxxx01001011x1x
2646                                                  ccmp.  */
2647                                               return 655;
2648                                             }
2649                                         }
2650                                       else
2651                                         {
2652                                           if (((word >> 12) & 0x1) == 0)
2653                                             {
2654                                               if (((word >> 13) & 0x1) == 0)
2655                                                 {
2656                                                   if (((word >> 14) & 0x1) == 0)
2657                                                     {
2658                                                       if (((word >> 16) & 0x1) == 0)
2659                                                         {
2660                                                           /* 33222222222211111111110000000000
2661                                                              10987654321098765432109876543210
2662                                                              xxxxxxxxxx00000x0xxxx01101011xxx
2663                                                              rbit.  */
2664                                                           return 679;
2665                                                         }
2666                                                       else
2667                                                         {
2668                                                           /* 33222222222211111111110000000000
2669                                                              10987654321098765432109876543210
2670                                                              xxxxxxxxxx00000x1xxxx01101011xxx
2671                                                              pacia.  */
2672                                                           return 687;
2673                                                         }
2674                                                     }
2675                                                   else
2676                                                     {
2677                                                       if (((word >> 30) & 0x1) == 0)
2678                                                         {
2679                                                           /* 33222222222211111111110000000000
2680                                                              10987654321098765432109876543210
2681                                                              xxxxxxxxxx00001xxxxxx01101011x0x
2682                                                              crc32b.  */
2683                                                           return 716;
2684                                                         }
2685                                                       else
2686                                                         {
2687                                                           /* 33222222222211111111110000000000
2688                                                              10987654321098765432109876543210
2689                                                              xxxxxxxxxx00001xxxxxx01101011x1x
2690                                                              xpaci.  */
2691                                                           return 703;
2692                                                         }
2693                                                     }
2694                                                 }
2695                                               else
2696                                                 {
2697                                                   if (((word >> 30) & 0x1) == 0)
2698                                                     {
2699                                                       /* 33222222222211111111110000000000
2700                                                          10987654321098765432109876543210
2701                                                          xxxxxxxxxx0001xxxxxxx01101011x0x
2702                                                          lslv.  */
2703                                                       return 707;
2704                                                     }
2705                                                   else
2706                                                     {
2707                                                       /* 33222222222211111111110000000000
2708                                                          10987654321098765432109876543210
2709                                                          xxxxxxxxxx0001xxxxxxx01101011x1x
2710                                                          paciza.  */
2711                                                       return 695;
2712                                                     }
2713                                                 }
2714                                             }
2715                                           else
2716                                             {
2717                                               if (((word >> 13) & 0x1) == 0)
2718                                                 {
2719                                                   if (((word >> 14) & 0x1) == 0)
2720                                                     {
2721                                                       if (((word >> 16) & 0x1) == 0)
2722                                                         {
2723                                                           /* 33222222222211111111110000000000
2724                                                              10987654321098765432109876543210
2725                                                              xxxxxxxxxx00100x0xxxx01101011xxx
2726                                                              clz.  */
2727                                                           return 684;
2728                                                         }
2729                                                       else
2730                                                         {
2731                                                           /* 33222222222211111111110000000000
2732                                                              10987654321098765432109876543210
2733                                                              xxxxxxxxxx00100x1xxxx01101011xxx
2734                                                              autia.  */
2735                                                           return 691;
2736                                                         }
2737                                                     }
2738                                                   else
2739                                                     {
2740                                                       /* 33222222222211111111110000000000
2741                                                          10987654321098765432109876543210
2742                                                          xxxxxxxxxx00101xxxxxx01101011xxx
2743                                                          crc32cb.  */
2744                                                       return 720;
2745                                                     }
2746                                                 }
2747                                               else
2748                                                 {
2749                                                   if (((word >> 30) & 0x1) == 0)
2750                                                     {
2751                                                       /* 33222222222211111111110000000000
2752                                                          10987654321098765432109876543210
2753                                                          xxxxxxxxxx0011xxxxxxx01101011x0x
2754                                                          pacga.  */
2755                                                       return 715;
2756                                                     }
2757                                                   else
2758                                                     {
2759                                                       /* 33222222222211111111110000000000
2760                                                          10987654321098765432109876543210
2761                                                          xxxxxxxxxx0011xxxxxxx01101011x1x
2762                                                          autiza.  */
2763                                                       return 699;
2764                                                     }
2765                                                 }
2766                                             }
2767                                         }
2768                                     }
2769                                 }
2770                               else
2771                                 {
2772                                   if (((word >> 23) & 0x1) == 0)
2773                                     {
2774                                       if (((word >> 30) & 0x1) == 0)
2775                                         {
2776                                           /* 33222222222211111111110000000000
2777                                              10987654321098765432109876543210
2778                                              xxxxxxxxxx01xxxxxxxxx0x001011x0x
2779                                              ccmn.  */
2780                                           return 652;
2781                                         }
2782                                       else
2783                                         {
2784                                           /* 33222222222211111111110000000000
2785                                              10987654321098765432109876543210
2786                                              xxxxxxxxxx01xxxxxxxxx0x001011x1x
2787                                              ccmp.  */
2788                                           return 653;
2789                                         }
2790                                     }
2791                                   else
2792                                     {
2793                                       if (((word >> 12) & 0x1) == 0)
2794                                         {
2795                                           if (((word >> 13) & 0x1) == 0)
2796                                             {
2797                                               if (((word >> 14) & 0x1) == 0)
2798                                                 {
2799                                                   if (((word >> 30) & 0x1) == 0)
2800                                                     {
2801                                                       /* 33222222222211111111110000000000
2802                                                          10987654321098765432109876543210
2803                                                          xxxxxxxxxx01000xxxxxx0x101011x0x
2804                                                          udiv.  */
2805                                                       return 705;
2806                                                     }
2807                                                   else
2808                                                     {
2809                                                       if (((word >> 16) & 0x1) == 0)
2810                                                         {
2811                                                           if (((word >> 31) & 0x1) == 0)
2812                                                             {
2813                                                               /* 33222222222211111111110000000000
2814                                                                  10987654321098765432109876543210
2815                                                                  xxxxxxxxxx01000x0xxxx0x101011x10
2816                                                                  rev.  */
2817                                                               return 681;
2818                                                             }
2819                                                           else
2820                                                             {
2821                                                               /* 33222222222211111111110000000000
2822                                                                  10987654321098765432109876543210
2823                                                                  xxxxxxxxxx01000x0xxxx0x101011x11
2824                                                                  rev32.  */
2825                                                               return 686;
2826                                                             }
2827                                                         }
2828                                                       else
2829                                                         {
2830                                                           /* 33222222222211111111110000000000
2831                                                              10987654321098765432109876543210
2832                                                              xxxxxxxxxx01000x1xxxx0x101011x1x
2833                                                              pacda.  */
2834                                                           return 689;
2835                                                         }
2836                                                     }
2837                                                 }
2838                                               else
2839                                                 {
2840                                                   /* 33222222222211111111110000000000
2841                                                      10987654321098765432109876543210
2842                                                      xxxxxxxxxx01001xxxxxx0x101011xxx
2843                                                      crc32w.  */
2844                                                   return 718;
2845                                                 }
2846                                             }
2847                                           else
2848                                             {
2849                                               if (((word >> 30) & 0x1) == 0)
2850                                                 {
2851                                                   /* 33222222222211111111110000000000
2852                                                      10987654321098765432109876543210
2853                                                      xxxxxxxxxx0101xxxxxxx0x101011x0x
2854                                                      asrv.  */
2855                                                   return 711;
2856                                                 }
2857                                               else
2858                                                 {
2859                                                   /* 33222222222211111111110000000000
2860                                                      10987654321098765432109876543210
2861                                                      xxxxxxxxxx0101xxxxxxx0x101011x1x
2862                                                      pacdza.  */
2863                                                   return 697;
2864                                                 }
2865                                             }
2866                                         }
2867                                       else
2868                                         {
2869                                           if (((word >> 13) & 0x1) == 0)
2870                                             {
2871                                               if (((word >> 14) & 0x1) == 0)
2872                                                 {
2873                                                   /* 33222222222211111111110000000000
2874                                                      10987654321098765432109876543210
2875                                                      xxxxxxxxxx01100xxxxxx0x101011xxx
2876                                                      autda.  */
2877                                                   return 693;
2878                                                 }
2879                                               else
2880                                                 {
2881                                                   /* 33222222222211111111110000000000
2882                                                      10987654321098765432109876543210
2883                                                      xxxxxxxxxx01101xxxxxx0x101011xxx
2884                                                      crc32cw.  */
2885                                                   return 722;
2886                                                 }
2887                                             }
2888                                           else
2889                                             {
2890                                               /* 33222222222211111111110000000000
2891                                                  10987654321098765432109876543210
2892                                                  xxxxxxxxxx0111xxxxxxx0x101011xxx
2893                                                  autdza.  */
2894                                               return 701;
2895                                             }
2896                                         }
2897                                     }
2898                                 }
2899                             }
2900                           else
2901                             {
2902                               if (((word >> 11) & 0x1) == 0)
2903                                 {
2904                                   if (((word >> 22) & 0x1) == 0)
2905                                     {
2906                                       if (((word >> 30) & 0x1) == 0)
2907                                         {
2908                                           /* 33222222222211111111110000000000
2909                                              10987654321098765432109876543210
2910                                              xxxxxxxxxx10xxxxxxxxx00x01011x0x
2911                                              csinc.  */
2912                                           return 657;
2913                                         }
2914                                       else
2915                                         {
2916                                           /* 33222222222211111111110000000000
2917                                              10987654321098765432109876543210
2918                                              xxxxxxxxxx10xxxxxxxxx00x01011x1x
2919                                              csneg.  */
2920                                           return 663;
2921                                         }
2922                                     }
2923                                   else
2924                                     {
2925                                       if (((word >> 12) & 0x1) == 0)
2926                                         {
2927                                           if (((word >> 13) & 0x1) == 0)
2928                                             {
2929                                               if (((word >> 14) & 0x1) == 0)
2930                                                 {
2931                                                   if (((word >> 16) & 0x1) == 0)
2932                                                     {
2933                                                       /* 33222222222211111111110000000000
2934                                                          10987654321098765432109876543210
2935                                                          xxxxxxxxxx10000x0xxxx01x01011xxx
2936                                                          rev16.  */
2937                                                       return 680;
2938                                                     }
2939                                                   else
2940                                                     {
2941                                                       /* 33222222222211111111110000000000
2942                                                          10987654321098765432109876543210
2943                                                          xxxxxxxxxx10000x1xxxx01x01011xxx
2944                                                          pacib.  */
2945                                                       return 688;
2946                                                     }
2947                                                 }
2948                                               else
2949                                                 {
2950                                                   if (((word >> 30) & 0x1) == 0)
2951                                                     {
2952                                                       /* 33222222222211111111110000000000
2953                                                          10987654321098765432109876543210
2954                                                          xxxxxxxxxx10001xxxxxx01x01011x0x
2955                                                          crc32h.  */
2956                                                       return 717;
2957                                                     }
2958                                                   else
2959                                                     {
2960                                                       /* 33222222222211111111110000000000
2961                                                          10987654321098765432109876543210
2962                                                          xxxxxxxxxx10001xxxxxx01x01011x1x
2963                                                          xpacd.  */
2964                                                       return 704;
2965                                                     }
2966                                                 }
2967                                             }
2968                                           else
2969                                             {
2970                                               if (((word >> 30) & 0x1) == 0)
2971                                                 {
2972                                                   /* 33222222222211111111110000000000
2973                                                      10987654321098765432109876543210
2974                                                      xxxxxxxxxx1001xxxxxxx01x01011x0x
2975                                                      lsrv.  */
2976                                                   return 709;
2977                                                 }
2978                                               else
2979                                                 {
2980                                                   /* 33222222222211111111110000000000
2981                                                      10987654321098765432109876543210
2982                                                      xxxxxxxxxx1001xxxxxxx01x01011x1x
2983                                                      pacizb.  */
2984                                                   return 696;
2985                                                 }
2986                                             }
2987                                         }
2988                                       else
2989                                         {
2990                                           if (((word >> 13) & 0x1) == 0)
2991                                             {
2992                                               if (((word >> 14) & 0x1) == 0)
2993                                                 {
2994                                                   if (((word >> 16) & 0x1) == 0)
2995                                                     {
2996                                                       /* 33222222222211111111110000000000
2997                                                          10987654321098765432109876543210
2998                                                          xxxxxxxxxx10100x0xxxx01x01011xxx
2999                                                          cls.  */
3000                                                       return 685;
3001                                                     }
3002                                                   else
3003                                                     {
3004                                                       /* 33222222222211111111110000000000
3005                                                          10987654321098765432109876543210
3006                                                          xxxxxxxxxx10100x1xxxx01x01011xxx
3007                                                          autib.  */
3008                                                       return 692;
3009                                                     }
3010                                                 }
3011                                               else
3012                                                 {
3013                                                   /* 33222222222211111111110000000000
3014                                                      10987654321098765432109876543210
3015                                                      xxxxxxxxxx10101xxxxxx01x01011xxx
3016                                                      crc32ch.  */
3017                                                   return 721;
3018                                                 }
3019                                             }
3020                                           else
3021                                             {
3022                                               /* 33222222222211111111110000000000
3023                                                  10987654321098765432109876543210
3024                                                  xxxxxxxxxx1011xxxxxxx01x01011xxx
3025                                                  autizb.  */
3026                                               return 700;
3027                                             }
3028                                         }
3029                                     }
3030                                 }
3031                               else
3032                                 {
3033                                   if (((word >> 12) & 0x1) == 0)
3034                                     {
3035                                       if (((word >> 13) & 0x1) == 0)
3036                                         {
3037                                           if (((word >> 14) & 0x1) == 0)
3038                                             {
3039                                               if (((word >> 30) & 0x1) == 0)
3040                                                 {
3041                                                   /* 33222222222211111111110000000000
3042                                                      10987654321098765432109876543210
3043                                                      xxxxxxxxxx11000xxxxxx0xx01011x0x
3044                                                      sdiv.  */
3045                                                   return 706;
3046                                                 }
3047                                               else
3048                                                 {
3049                                                   if (((word >> 16) & 0x1) == 0)
3050                                                     {
3051                                                       /* 33222222222211111111110000000000
3052                                                          10987654321098765432109876543210
3053                                                          xxxxxxxxxx11000x0xxxx0xx01011x1x
3054                                                          rev.  */
3055                                                       return 682;
3056                                                     }
3057                                                   else
3058                                                     {
3059                                                       /* 33222222222211111111110000000000
3060                                                          10987654321098765432109876543210
3061                                                          xxxxxxxxxx11000x1xxxx0xx01011x1x
3062                                                          pacdb.  */
3063                                                       return 690;
3064                                                     }
3065                                                 }
3066                                             }
3067                                           else
3068                                             {
3069                                               /* 33222222222211111111110000000000
3070                                                  10987654321098765432109876543210
3071                                                  xxxxxxxxxx11001xxxxxx0xx01011xxx
3072                                                  crc32x.  */
3073                                               return 719;
3074                                             }
3075                                         }
3076                                       else
3077                                         {
3078                                           if (((word >> 30) & 0x1) == 0)
3079                                             {
3080                                               /* 33222222222211111111110000000000
3081                                                  10987654321098765432109876543210
3082                                                  xxxxxxxxxx1101xxxxxxx0xx01011x0x
3083                                                  rorv.  */
3084                                               return 713;
3085                                             }
3086                                           else
3087                                             {
3088                                               /* 33222222222211111111110000000000
3089                                                  10987654321098765432109876543210
3090                                                  xxxxxxxxxx1101xxxxxxx0xx01011x1x
3091                                                  pacdzb.  */
3092                                               return 698;
3093                                             }
3094                                         }
3095                                     }
3096                                   else
3097                                     {
3098                                       if (((word >> 13) & 0x1) == 0)
3099                                         {
3100                                           if (((word >> 14) & 0x1) == 0)
3101                                             {
3102                                               /* 33222222222211111111110000000000
3103                                                  10987654321098765432109876543210
3104                                                  xxxxxxxxxx11100xxxxxx0xx01011xxx
3105                                                  autdb.  */
3106                                               return 694;
3107                                             }
3108                                           else
3109                                             {
3110                                               /* 33222222222211111111110000000000
3111                                                  10987654321098765432109876543210
3112                                                  xxxxxxxxxx11101xxxxxx0xx01011xxx
3113                                                  crc32cx.  */
3114                                               return 723;
3115                                             }
3116                                         }
3117                                       else
3118                                         {
3119                                           /* 33222222222211111111110000000000
3120                                              10987654321098765432109876543210
3121                                              xxxxxxxxxx1111xxxxxxx0xx01011xxx
3122                                              autdzb.  */
3123                                           return 702;
3124                                         }
3125                                     }
3126                                 }
3127                             }
3128                         }
3129                     }
3130                   else
3131                     {
3132                       if (((word >> 29) & 0x1) == 0)
3133                         {
3134                           if (((word >> 30) & 0x1) == 0)
3135                             {
3136                               /* 33222222222211111111110000000000
3137                                  10987654321098765432109876543210
3138                                  xxxxxxxxxxxxxxxxxxxxx1xx0101x00x
3139                                  bic.  */
3140                               return 967;
3141                             }
3142                           else
3143                             {
3144                               /* 33222222222211111111110000000000
3145                                  10987654321098765432109876543210
3146                                  xxxxxxxxxxxxxxxxxxxxx1xx0101x01x
3147                                  eon.  */
3148                               return 974;
3149                             }
3150                         }
3151                       else
3152                         {
3153                           if (((word >> 30) & 0x1) == 0)
3154                             {
3155                               /* 33222222222211111111110000000000
3156                                  10987654321098765432109876543210
3157                                  xxxxxxxxxxxxxxxxxxxxx1xx0101x10x
3158                                  orn.  */
3159                               return 971;
3160                             }
3161                           else
3162                             {
3163                               /* 33222222222211111111110000000000
3164                                  10987654321098765432109876543210
3165                                  xxxxxxxxxxxxxxxxxxxxx1xx0101x11x
3166                                  bics.  */
3167                               return 977;
3168                             }
3169                         }
3170                     }
3171                 }
3172             }
3173           else
3174             {
3175               if (((word >> 27) & 0x1) == 0)
3176                 {
3177                   if (((word >> 23) & 0x1) == 0)
3178                     {
3179                       if (((word >> 29) & 0x1) == 0)
3180                         {
3181                           if (((word >> 30) & 0x1) == 0)
3182                             {
3183                               /* 33222222222211111111110000000000
3184                                  10987654321098765432109876543210
3185                                  xxxxxxxxxxxxxxxxxxxxxxx01100x00x
3186                                  sbfm.  */
3187                               return 612;
3188                             }
3189                           else
3190                             {
3191                               /* 33222222222211111111110000000000
3192                                  10987654321098765432109876543210
3193                                  xxxxxxxxxxxxxxxxxxxxxxx01100x01x
3194                                  ubfm.  */
3195                               return 623;
3196                             }
3197                         }
3198                       else
3199                         {
3200                           /* 33222222222211111111110000000000
3201                              10987654321098765432109876543210
3202                              xxxxxxxxxxxxxxxxxxxxxxx01100x1xx
3203                              bfm.  */
3204                           return 619;
3205                         }
3206                     }
3207                   else
3208                     {
3209                       /* 33222222222211111111110000000000
3210                          10987654321098765432109876543210
3211                          xxxxxxxxxxxxxxxxxxxxxxx11100xxxx
3212                          extr.  */
3213                       return 746;
3214                     }
3215                 }
3216               else
3217                 {
3218                   if (((word >> 21) & 0x1) == 0)
3219                     {
3220                       if (((word >> 28) & 0x1) == 0)
3221                         {
3222                           if (((word >> 29) & 0x1) == 0)
3223                             {
3224                               if (((word >> 30) & 0x1) == 0)
3225                                 {
3226                                   /* 33222222222211111111110000000000
3227                                      10987654321098765432109876543210
3228                                      xxxxxxxxxxxxxxxxxxxxx0xx1101000x
3229                                      add.  */
3230                                   return 19;
3231                                 }
3232                               else
3233                                 {
3234                                   /* 33222222222211111111110000000000
3235                                      10987654321098765432109876543210
3236                                      xxxxxxxxxxxxxxxxxxxxx0xx1101001x
3237                                      sub.  */
3238                                   return 22;
3239                                 }
3240                             }
3241                           else
3242                             {
3243                               if (((word >> 30) & 0x1) == 0)
3244                                 {
3245                                   /* 33222222222211111111110000000000
3246                                      10987654321098765432109876543210
3247                                      xxxxxxxxxxxxxxxxxxxxx0xx1101010x
3248                                      adds.  */
3249                                   return 20;
3250                                 }
3251                               else
3252                                 {
3253                                   /* 33222222222211111111110000000000
3254                                      10987654321098765432109876543210
3255                                      xxxxxxxxxxxxxxxxxxxxx0xx1101011x
3256                                      subs.  */
3257                                   return 24;
3258                                 }
3259                             }
3260                         }
3261                       else
3262                         {
3263                           if (((word >> 15) & 0x1) == 0)
3264                             {
3265                               if (((word >> 22) & 0x1) == 0)
3266                                 {
3267                                   /* 33222222222211111111110000000000
3268                                      10987654321098765432109876543210
3269                                      xxxxxxxxxxxxxxx0xxxxx00x11011xxx
3270                                      madd.  */
3271                                   return 724;
3272                                 }
3273                               else
3274                                 {
3275                                   if (((word >> 23) & 0x1) == 0)
3276                                     {
3277                                       /* 33222222222211111111110000000000
3278                                          10987654321098765432109876543210
3279                                          xxxxxxxxxxxxxxx0xxxxx01011011xxx
3280                                          smulh.  */
3281                                       return 732;
3282                                     }
3283                                   else
3284                                     {
3285                                       /* 33222222222211111111110000000000
3286                                          10987654321098765432109876543210
3287                                          xxxxxxxxxxxxxxx0xxxxx01111011xxx
3288                                          umulh.  */
3289                                       return 737;
3290                                     }
3291                                 }
3292                             }
3293                           else
3294                             {
3295                               /* 33222222222211111111110000000000
3296                                  10987654321098765432109876543210
3297                                  xxxxxxxxxxxxxxx1xxxxx0xx11011xxx
3298                                  msub.  */
3299                               return 726;
3300                             }
3301                         }
3302                     }
3303                   else
3304                     {
3305                       if (((word >> 23) & 0x1) == 0)
3306                         {
3307                           if (((word >> 28) & 0x1) == 0)
3308                             {
3309                               if (((word >> 29) & 0x1) == 0)
3310                                 {
3311                                   if (((word >> 30) & 0x1) == 0)
3312                                     {
3313                                       /* 33222222222211111111110000000000
3314                                          10987654321098765432109876543210
3315                                          xxxxxxxxxxxxxxxxxxxxx1x01101000x
3316                                          add.  */
3317                                       return 6;
3318                                     }
3319                                   else
3320                                     {
3321                                       /* 33222222222211111111110000000000
3322                                          10987654321098765432109876543210
3323                                          xxxxxxxxxxxxxxxxxxxxx1x01101001x
3324                                          sub.  */
3325                                       return 9;
3326                                     }
3327                                 }
3328                               else
3329                                 {
3330                                   if (((word >> 30) & 0x1) == 0)
3331                                     {
3332                                       /* 33222222222211111111110000000000
3333                                          10987654321098765432109876543210
3334                                          xxxxxxxxxxxxxxxxxxxxx1x01101010x
3335                                          adds.  */
3336                                       return 7;
3337                                     }
3338                                   else
3339                                     {
3340                                       /* 33222222222211111111110000000000
3341                                          10987654321098765432109876543210
3342                                          xxxxxxxxxxxxxxxxxxxxx1x01101011x
3343                                          subs.  */
3344                                       return 10;
3345                                     }
3346                                 }
3347                             }
3348                           else
3349                             {
3350                               if (((word >> 15) & 0x1) == 0)
3351                                 {
3352                                   /* 33222222222211111111110000000000
3353                                      10987654321098765432109876543210
3354                                      xxxxxxxxxxxxxxx0xxxxx1x011011xxx
3355                                      smaddl.  */
3356                                   return 728;
3357                                 }
3358                               else
3359                                 {
3360                                   /* 33222222222211111111110000000000
3361                                      10987654321098765432109876543210
3362                                      xxxxxxxxxxxxxxx1xxxxx1x011011xxx
3363                                      smsubl.  */
3364                                   return 730;
3365                                 }
3366                             }
3367                         }
3368                       else
3369                         {
3370                           if (((word >> 15) & 0x1) == 0)
3371                             {
3372                               /* 33222222222211111111110000000000
3373                                  10987654321098765432109876543210
3374                                  xxxxxxxxxxxxxxx0xxxxx1x11101xxxx
3375                                  umaddl.  */
3376                               return 733;
3377                             }
3378                           else
3379                             {
3380                               /* 33222222222211111111110000000000
3381                                  10987654321098765432109876543210
3382                                  xxxxxxxxxxxxxxx1xxxxx1x11101xxxx
3383                                  umsubl.  */
3384                               return 735;
3385                             }
3386                         }
3387                     }
3388                 }
3389             }
3390         }
3391     }
3392   else
3393     {
3394       if (((word >> 27) & 0x1) == 0)
3395         {
3396           if (((word >> 28) & 0x1) == 0)
3397             {
3398               if (((word >> 24) & 0x1) == 0)
3399                 {
3400                   if (((word >> 29) & 0x1) == 0)
3401                     {
3402                       if (((word >> 13) & 0x1) == 0)
3403                         {
3404                           if (((word >> 14) & 0x1) == 0)
3405                             {
3406                               if (((word >> 15) & 0x1) == 0)
3407                                 {
3408                                   if (((word >> 21) & 0x1) == 0)
3409                                     {
3410                                       if (((word >> 30) & 0x1) == 0)
3411                                         {
3412                                           if (((word >> 31) & 0x1) == 0)
3413                                             {
3414                                               if (((word >> 16) & 0x1) == 0)
3415                                                 {
3416                                                   if (((word >> 17) & 0x1) == 0)
3417                                                     {
3418                                                       if (((word >> 18) & 0x1) == 0)
3419                                                         {
3420                                                           if (((word >> 19) & 0x1) == 0)
3421                                                             {
3422                                                               if (((word >> 20) & 0x1) == 0)
3423                                                                 {
3424                                                                   /* 33222222222211111111110000000000
3425                                                                      10987654321098765432109876543210
3426                                                                      xxxxxxxxxxxxx000000000xx0x100000
3427                                                                      add.  */
3428                                                                   return 1232;
3429                                                                 }
3430                                                               else
3431                                                                 {
3432                                                                   /* 33222222222211111111110000000000
3433                                                                      10987654321098765432109876543210
3434                                                                      xxxxxxxxxxxxx000000010xx0x100000
3435                                                                      mul.  */
3436                                                                   return 1685;
3437                                                                 }
3438                                                             }
3439                                                           else
3440                                                             {
3441                                                               if (((word >> 20) & 0x1) == 0)
3442                                                                 {
3443                                                                   /* 33222222222211111111110000000000
3444                                                                      10987654321098765432109876543210
3445                                                                      xxxxxxxxxxxxx000000100xx0x100000
3446                                                                      smax.  */
3447                                                                   return 1764;
3448                                                                 }
3449                                                               else
3450                                                                 {
3451                                                                   /* 33222222222211111111110000000000
3452                                                                      10987654321098765432109876543210
3453                                                                      xxxxxxxxxxxxx000000110xx0x100000
3454                                                                      orr.  */
3455                                                                   return 1696;
3456                                                                 }
3457                                                             }
3458                                                         }
3459                                                       else
3460                                                         {
3461                                                           if (((word >> 19) & 0x1) == 0)
3462                                                             {
3463                                                               /* 33222222222211111111110000000000
3464                                                                  10987654321098765432109876543210
3465                                                                  xxxxxxxxxxxxx0000010x0xx0x100000
3466                                                                  sdiv.  */
3467                                                               return 1755;
3468                                                             }
3469                                                           else
3470                                                             {
3471                                                               /* 33222222222211111111110000000000
3472                                                                  10987654321098765432109876543210
3473                                                                  xxxxxxxxxxxxx0000011x0xx0x100000
3474                                                                  sabd.  */
3475                                                               return 1746;
3476                                                             }
3477                                                         }
3478                                                     }
3479                                                   else
3480                                                     {
3481                                                       if (((word >> 18) & 0x1) == 0)
3482                                                         {
3483                                                           if (((word >> 19) & 0x1) == 0)
3484                                                             {
3485                                                               /* 33222222222211111111110000000000
3486                                                                  10987654321098765432109876543210
3487                                                                  xxxxxxxxxxxxx0000100x0xx0x100000
3488                                                                  smulh.  */
3489                                                               return 1769;
3490                                                             }
3491                                                           else
3492                                                             {
3493                                                               if (((word >> 20) & 0x1) == 0)
3494                                                                 {
3495                                                                   /* 33222222222211111111110000000000
3496                                                                      10987654321098765432109876543210
3497                                                                      xxxxxxxxxxxxx000010100xx0x100000
3498                                                                      smin.  */
3499                                                                   return 1767;
3500                                                                 }
3501                                                               else
3502                                                                 {
3503                                                                   /* 33222222222211111111110000000000
3504                                                                      10987654321098765432109876543210
3505                                                                      xxxxxxxxxxxxx000010110xx0x100000
3506                                                                      and.  */
3507                                                                   return 1240;
3508                                                                 }
3509                                                             }
3510                                                         }
3511                                                       else
3512                                                         {
3513                                                           /* 33222222222211111111110000000000
3514                                                              10987654321098765432109876543210
3515                                                              xxxxxxxxxxxxx000011xx0xx0x100000
3516                                                              sdivr.  */
3517                                                           return 1756;
3518                                                         }
3519                                                     }
3520                                                 }
3521                                               else
3522                                                 {
3523                                                   if (((word >> 17) & 0x1) == 0)
3524                                                     {
3525                                                       if (((word >> 18) & 0x1) == 0)
3526                                                         {
3527                                                           if (((word >> 19) & 0x1) == 0)
3528                                                             {
3529                                                               /* 33222222222211111111110000000000
3530                                                                  10987654321098765432109876543210
3531                                                                  xxxxxxxxxxxxx0001000x0xx0x100000
3532                                                                  sub.  */
3533                                                               return 1885;
3534                                                             }
3535                                                           else
3536                                                             {
3537                                                               if (((word >> 20) & 0x1) == 0)
3538                                                                 {
3539                                                                   /* 33222222222211111111110000000000
3540                                                                      10987654321098765432109876543210
3541                                                                      xxxxxxxxxxxxx000100100xx0x100000
3542                                                                      umax.  */
3543                                                                   return 1913;
3544                                                                 }
3545                                                               else
3546                                                                 {
3547                                                                   /* 33222222222211111111110000000000
3548                                                                      10987654321098765432109876543210
3549                                                                      xxxxxxxxxxxxx000100110xx0x100000
3550                                                                      eor.  */
3551                                                                   return 1327;
3552                                                                 }
3553                                                             }
3554                                                         }
3555                                                       else
3556                                                         {
3557                                                           if (((word >> 19) & 0x1) == 0)
3558                                                             {
3559                                                               /* 33222222222211111111110000000000
3560                                                                  10987654321098765432109876543210
3561                                                                  xxxxxxxxxxxxx0001010x0xx0x100000
3562                                                                  udiv.  */
3563                                                               return 1907;
3564                                                             }
3565                                                           else
3566                                                             {
3567                                                               /* 33222222222211111111110000000000
3568                                                                  10987654321098765432109876543210
3569                                                                  xxxxxxxxxxxxx0001011x0xx0x100000
3570                                                                  uabd.  */
3571                                                               return 1898;
3572                                                             }
3573                                                         }
3574                                                     }
3575                                                   else
3576                                                     {
3577                                                       if (((word >> 18) & 0x1) == 0)
3578                                                         {
3579                                                           if (((word >> 19) & 0x1) == 0)
3580                                                             {
3581                                                               if (((word >> 20) & 0x1) == 0)
3582                                                                 {
3583                                                                   /* 33222222222211111111110000000000
3584                                                                      10987654321098765432109876543210
3585                                                                      xxxxxxxxxxxxx000110000xx0x100000
3586                                                                      subr.  */
3587                                                                   return 1887;
3588                                                                 }
3589                                                               else
3590                                                                 {
3591                                                                   /* 33222222222211111111110000000000
3592                                                                      10987654321098765432109876543210
3593                                                                      xxxxxxxxxxxxx000110010xx0x100000
3594                                                                      umulh.  */
3595                                                                   return 1918;
3596                                                                 }
3597                                                             }
3598                                                           else
3599                                                             {
3600                                                               if (((word >> 20) & 0x1) == 0)
3601                                                                 {
3602                                                                   /* 33222222222211111111110000000000
3603                                                                      10987654321098765432109876543210
3604                                                                      xxxxxxxxxxxxx000110100xx0x100000
3605                                                                      umin.  */
3606                                                                   return 1916;
3607                                                                 }
3608                                                               else
3609                                                                 {
3610                                                                   /* 33222222222211111111110000000000
3611                                                                      10987654321098765432109876543210
3612                                                                      xxxxxxxxxxxxx000110110xx0x100000
3613                                                                      bic.  */
3614                                                                   return 1252;
3615                                                                 }
3616                                                             }
3617                                                         }
3618                                                       else
3619                                                         {
3620                                                           /* 33222222222211111111110000000000
3621                                                              10987654321098765432109876543210
3622                                                              xxxxxxxxxxxxx000111xx0xx0x100000
3623                                                              udivr.  */
3624                                                           return 1908;
3625                                                         }
3626                                                     }
3627                                                 }
3628                                             }
3629                                           else
3630                                             {
3631                                               if (((word >> 23) & 0x1) == 0)
3632                                                 {
3633                                                   /* 33222222222211111111110000000000
3634                                                      10987654321098765432109876543210
3635                                                      xxxxxxxxxxxxx000xxxxx0x00x100001
3636                                                      ld1sb.  */
3637                                                   return 1514;
3638                                                 }
3639                                               else
3640                                                 {
3641                                                   /* 33222222222211111111110000000000
3642                                                      10987654321098765432109876543210
3643                                                      xxxxxxxxxxxxx000xxxxx0x10x100001
3644                                                      ld1sh.  */
3645                                                   return 1525;
3646                                                 }
3647                                             }
3648                                         }
3649                                       else
3650                                         {
3651                                           if (((word >> 23) & 0x1) == 0)
3652                                             {
3653                                               /* 33222222222211111111110000000000
3654                                                  10987654321098765432109876543210
3655                                                  xxxxxxxxxxxxx000xxxxx0x00x10001x
3656                                                  ld1sb.  */
3657                                               return 1518;
3658                                             }
3659                                           else
3660                                             {
3661                                               if (((word >> 31) & 0x1) == 0)
3662                                                 {
3663                                                   if (((word >> 10) & 0x1) == 0)
3664                                                     {
3665                                                       /* 33222222222211111111110000000000
3666                                                          10987654321098765432109876543210
3667                                                          xxxxxxxxxx0xx000xxxxx0x10x100010
3668                                                          sdot.  */
3669                                                       return 1757;
3670                                                     }
3671                                                   else
3672                                                     {
3673                                                       /* 33222222222211111111110000000000
3674                                                          10987654321098765432109876543210
3675                                                          xxxxxxxxxx1xx000xxxxx0x10x100010
3676                                                          udot.  */
3677                                                       return 1909;
3678                                                     }
3679                                                 }
3680                                               else
3681                                                 {
3682                                                   /* 33222222222211111111110000000000
3683                                                      10987654321098765432109876543210
3684                                                      xxxxxxxxxxxxx000xxxxx0x10x100011
3685                                                      ld1sh.  */
3686                                                   return 1529;
3687                                                 }
3688                                             }
3689                                         }
3690                                     }
3691                                   else
3692                                     {
3693                                       if (((word >> 30) & 0x1) == 0)
3694                                         {
3695                                           if (((word >> 31) & 0x1) == 0)
3696                                             {
3697                                               if (((word >> 10) & 0x1) == 0)
3698                                                 {
3699                                                   if (((word >> 11) & 0x1) == 0)
3700                                                     {
3701                                                       if (((word >> 12) & 0x1) == 0)
3702                                                         {
3703                                                           /* 33222222222211111111110000000000
3704                                                              10987654321098765432109876543210
3705                                                              xxxxxxxxxx000000xxxxx1xx0x100000
3706                                                              add.  */
3707                                                           return 1230;
3708                                                         }
3709                                                       else
3710                                                         {
3711                                                           /* 33222222222211111111110000000000
3712                                                              10987654321098765432109876543210
3713                                                              xxxxxxxxxx001000xxxxx1xx0x100000
3714                                                              sqadd.  */
3715                                                           return 1771;
3716                                                         }
3717                                                     }
3718                                                   else
3719                                                     {
3720                                                       /* 33222222222211111111110000000000
3721                                                          10987654321098765432109876543210
3722                                                          xxxxxxxxxx01x000xxxxx1xx0x100000
3723                                                          sqsub.  */
3724                                                       return 1801;
3725                                                     }
3726                                                 }
3727                                               else
3728                                                 {
3729                                                   if (((word >> 11) & 0x1) == 0)
3730                                                     {
3731                                                       if (((word >> 12) & 0x1) == 0)
3732                                                         {
3733                                                           /* 33222222222211111111110000000000
3734                                                              10987654321098765432109876543210
3735                                                              xxxxxxxxxx100000xxxxx1xx0x100000
3736                                                              sub.  */
3737                                                           return 1883;
3738                                                         }
3739                                                       else
3740                                                         {
3741                                                           /* 33222222222211111111110000000000
3742                                                              10987654321098765432109876543210
3743                                                              xxxxxxxxxx101000xxxxx1xx0x100000
3744                                                              uqadd.  */
3745                                                           return 1919;
3746                                                         }
3747                                                     }
3748                                                   else
3749                                                     {
3750                                                       /* 33222222222211111111110000000000
3751                                                          10987654321098765432109876543210
3752                                                          xxxxxxxxxx11x000xxxxx1xx0x100000
3753                                                          uqsub.  */
3754                                                       return 1949;
3755                                                     }
3756                                                 }
3757                                             }
3758                                           else
3759                                             {
3760                                               if (((word >> 23) & 0x1) == 0)
3761                                                 {
3762                                                   /* 33222222222211111111110000000000
3763                                                      10987654321098765432109876543210
3764                                                      xxxxxxxxxxxxx000xxxxx1x00x100001
3765                                                      prfb.  */
3766                                                   return 1704;
3767                                                 }
3768                                               else
3769                                                 {
3770                                                   /* 33222222222211111111110000000000
3771                                                      10987654321098765432109876543210
3772                                                      xxxxxxxxxxxxx000xxxxx1x10x100001
3773                                                      ld1sh.  */
3774                                                   return 1526;
3775                                                 }
3776                                             }
3777                                         }
3778                                       else
3779                                         {
3780                                           if (((word >> 23) & 0x1) == 0)
3781                                             {
3782                                               /* 33222222222211111111110000000000
3783                                                  10987654321098765432109876543210
3784                                                  xxxxxxxxxxxxx000xxxxx1x00x10001x
3785                                                  prfb.  */
3786                                               return 1705;
3787                                             }
3788                                           else
3789                                             {
3790                                               if (((word >> 31) & 0x1) == 0)
3791                                                 {
3792                                                   if (((word >> 10) & 0x1) == 0)
3793                                                     {
3794                                                       if (((word >> 22) & 0x1) == 0)
3795                                                         {
3796                                                           /* 33222222222211111111110000000000
3797                                                              10987654321098765432109876543210
3798                                                              xxxxxxxxxx0xx000xxxxx1010x100010
3799                                                              sdot.  */
3800                                                           return 1758;
3801                                                         }
3802                                                       else
3803                                                         {
3804                                                           /* 33222222222211111111110000000000
3805                                                              10987654321098765432109876543210
3806                                                              xxxxxxxxxx0xx000xxxxx1110x100010
3807                                                              sdot.  */
3808                                                           return 1759;
3809                                                         }
3810                                                     }
3811                                                   else
3812                                                     {
3813                                                       if (((word >> 22) & 0x1) == 0)
3814                                                         {
3815                                                           /* 33222222222211111111110000000000
3816                                                              10987654321098765432109876543210
3817                                                              xxxxxxxxxx1xx000xxxxx1010x100010
3818                                                              udot.  */
3819                                                           return 1910;
3820                                                         }
3821                                                       else
3822                                                         {
3823                                                           /* 33222222222211111111110000000000
3824                                                              10987654321098765432109876543210
3825                                                              xxxxxxxxxx1xx000xxxxx1110x100010
3826                                                              udot.  */
3827                                                           return 1911;
3828                                                         }
3829                                                     }
3830                                                 }
3831                                               else
3832                                                 {
3833                                                   /* 33222222222211111111110000000000
3834                                                      10987654321098765432109876543210
3835                                                      xxxxxxxxxxxxx000xxxxx1x10x100011
3836                                                      ld1sh.  */
3837                                                   return 1530;
3838                                                 }
3839                                             }
3840                                         }
3841                                     }
3842                                 }
3843                               else
3844                                 {
3845                                   if (((word >> 30) & 0x1) == 0)
3846                                     {
3847                                       if (((word >> 31) & 0x1) == 0)
3848                                         {
3849                                           if (((word >> 21) & 0x1) == 0)
3850                                             {
3851                                               if (((word >> 16) & 0x1) == 0)
3852                                                 {
3853                                                   if (((word >> 18) & 0x1) == 0)
3854                                                     {
3855                                                       if (((word >> 19) & 0x1) == 0)
3856                                                         {
3857                                                           if (((word >> 20) & 0x1) == 0)
3858                                                             {
3859                                                               /* 33222222222211111111110000000000
3860                                                                  10987654321098765432109876543210
3861                                                                  xxxxxxxxxxxxx0010x0000xx0x100000
3862                                                                  asr.  */
3863                                                               return 1248;
3864                                                             }
3865                                                           else
3866                                                             {
3867                                                               /* 33222222222211111111110000000000
3868                                                                  10987654321098765432109876543210
3869                                                                  xxxxxxxxxxxxx0010x0010xx0x100000
3870                                                                  asr.  */
3871                                                               return 1246;
3872                                                             }
3873                                                         }
3874                                                       else
3875                                                         {
3876                                                           /* 33222222222211111111110000000000
3877                                                              10987654321098765432109876543210
3878                                                              xxxxxxxxxxxxx0010x01x0xx0x100000
3879                                                              asr.  */
3880                                                           return 1247;
3881                                                         }
3882                                                     }
3883                                                   else
3884                                                     {
3885                                                       if (((word >> 20) & 0x1) == 0)
3886                                                         {
3887                                                           /* 33222222222211111111110000000000
3888                                                              10987654321098765432109876543210
3889                                                              xxxxxxxxxxxxx0010x1x00xx0x100000
3890                                                              asrd.  */
3891                                                           return 1249;
3892                                                         }
3893                                                       else
3894                                                         {
3895                                                           /* 33222222222211111111110000000000
3896                                                              10987654321098765432109876543210
3897                                                              xxxxxxxxxxxxx0010x1x10xx0x100000
3898                                                              asrr.  */
3899                                                           return 1250;
3900                                                         }
3901                                                     }
3902                                                 }
3903                                               else
3904                                                 {
3905                                                   if (((word >> 17) & 0x1) == 0)
3906                                                     {
3907                                                       if (((word >> 18) & 0x1) == 0)
3908                                                         {
3909                                                           if (((word >> 19) & 0x1) == 0)
3910                                                             {
3911                                                               if (((word >> 20) & 0x1) == 0)
3912                                                                 {
3913                                                                   /* 33222222222211111111110000000000
3914                                                                      10987654321098765432109876543210
3915                                                                      xxxxxxxxxxxxx001100000xx0x100000
3916                                                                      lsr.  */
3917                                                                   return 1676;
3918                                                                 }
3919                                                               else
3920                                                                 {
3921                                                                   /* 33222222222211111111110000000000
3922                                                                      10987654321098765432109876543210
3923                                                                      xxxxxxxxxxxxx001100010xx0x100000
3924                                                                      lsr.  */
3925                                                                   return 1674;
3926                                                                 }
3927                                                             }
3928                                                           else
3929                                                             {
3930                                                               /* 33222222222211111111110000000000
3931                                                                  10987654321098765432109876543210
3932                                                                  xxxxxxxxxxxxx0011001x0xx0x100000
3933                                                                  lsr.  */
3934                                                               return 1675;
3935                                                             }
3936                                                         }
3937                                                       else
3938                                                         {
3939                                                           /* 33222222222211111111110000000000
3940                                                              10987654321098765432109876543210
3941                                                              xxxxxxxxxxxxx001101xx0xx0x100000
3942                                                              lsrr.  */
3943                                                           return 1677;
3944                                                         }
3945                                                     }
3946                                                   else
3947                                                     {
3948                                                       if (((word >> 18) & 0x1) == 0)
3949                                                         {
3950                                                           if (((word >> 19) & 0x1) == 0)
3951                                                             {
3952                                                               if (((word >> 20) & 0x1) == 0)
3953                                                                 {
3954                                                                   /* 33222222222211111111110000000000
3955                                                                      10987654321098765432109876543210
3956                                                                      xxxxxxxxxxxxx001110000xx0x100000
3957                                                                      lsl.  */
3958                                                                   return 1670;
3959                                                                 }
3960                                                               else
3961                                                                 {
3962                                                                   /* 33222222222211111111110000000000
3963                                                                      10987654321098765432109876543210
3964                                                                      xxxxxxxxxxxxx001110010xx0x100000
3965                                                                      lsl.  */
3966                                                                   return 1668;
3967                                                                 }
3968                                                             }
3969                                                           else
3970                                                             {
3971                                                               /* 33222222222211111111110000000000
3972                                                                  10987654321098765432109876543210
3973                                                                  xxxxxxxxxxxxx0011101x0xx0x100000
3974                                                                  lsl.  */
3975                                                               return 1669;
3976                                                             }
3977                                                         }
3978                                                       else
3979                                                         {
3980                                                           /* 33222222222211111111110000000000
3981                                                              10987654321098765432109876543210
3982                                                              xxxxxxxxxxxxx001111xx0xx0x100000
3983                                                              lslr.  */
3984                                                           return 1671;
3985                                                         }
3986                                                     }
3987                                                 }
3988                                             }
3989                                           else
3990                                             {
3991                                               if (((word >> 10) & 0x1) == 0)
3992                                                 {
3993                                                   if (((word >> 12) & 0x1) == 0)
3994                                                     {
3995                                                       /* 33222222222211111111110000000000
3996                                                          10987654321098765432109876543210
3997                                                          xxxxxxxxxx0x0001xxxxx1xx0x100000
3998                                                          asr.  */
3999                                                       return 1244;
4000                                                     }
4001                                                   else
4002                                                     {
4003                                                       /* 33222222222211111111110000000000
4004                                                          10987654321098765432109876543210
4005                                                          xxxxxxxxxx0x1001xxxxx1xx0x100000
4006                                                          asr.  */
4007                                                       return 1245;
4008                                                     }
4009                                                 }
4010                                               else
4011                                                 {
4012                                                   if (((word >> 11) & 0x1) == 0)
4013                                                     {
4014                                                       if (((word >> 12) & 0x1) == 0)
4015                                                         {
4016                                                           /* 33222222222211111111110000000000
4017                                                              10987654321098765432109876543210
4018                                                              xxxxxxxxxx100001xxxxx1xx0x100000
4019                                                              lsr.  */
4020                                                           return 1672;
4021                                                         }
4022                                                       else
4023                                                         {
4024                                                           /* 33222222222211111111110000000000
4025                                                              10987654321098765432109876543210
4026                                                              xxxxxxxxxx101001xxxxx1xx0x100000
4027                                                              lsr.  */
4028                                                           return 1673;
4029                                                         }
4030                                                     }
4031                                                   else
4032                                                     {
4033                                                       if (((word >> 12) & 0x1) == 0)
4034                                                         {
4035                                                           /* 33222222222211111111110000000000
4036                                                              10987654321098765432109876543210
4037                                                              xxxxxxxxxx110001xxxxx1xx0x100000
4038                                                              lsl.  */
4039                                                           return 1666;
4040                                                         }
4041                                                       else
4042                                                         {
4043                                                           /* 33222222222211111111110000000000
4044                                                              10987654321098765432109876543210
4045                                                              xxxxxxxxxx111001xxxxx1xx0x100000
4046                                                              lsl.  */
4047                                                           return 1667;
4048                                                         }
4049                                                     }
4050                                                 }
4051                                             }
4052                                         }
4053                                       else
4054                                         {
4055                                           if (((word >> 22) & 0x1) == 0)
4056                                             {
4057                                               if (((word >> 23) & 0x1) == 0)
4058                                                 {
4059                                                   /* 33222222222211111111110000000000
4060                                                      10987654321098765432109876543210
4061                                                      xxxxxxxxxxxxx001xxxxxx000x100001
4062                                                      ld1sb.  */
4063                                                   return 1520;
4064                                                 }
4065                                               else
4066                                                 {
4067                                                   /* 33222222222211111111110000000000
4068                                                      10987654321098765432109876543210
4069                                                      xxxxxxxxxxxxx001xxxxxx010x100001
4070                                                      ld1sh.  */
4071                                                   return 1533;
4072                                                 }
4073                                             }
4074                                           else
4075                                             {
4076                                               if (((word >> 23) & 0x1) == 0)
4077                                                 {
4078                                                   /* 33222222222211111111110000000000
4079                                                      10987654321098765432109876543210
4080                                                      xxxxxxxxxxxxx001xxxxxx100x100001
4081                                                      ld1rb.  */
4082                                                   return 1490;
4083                                                 }
4084                                               else
4085                                                 {
4086                                                   /* 33222222222211111111110000000000
4087                                                      10987654321098765432109876543210
4088                                                      xxxxxxxxxxxxx001xxxxxx110x100001
4089                                                      ld1rsw.  */
4090                                                   return 1511;
4091                                                 }
4092                                             }
4093                                         }
4094                                     }
4095                                   else
4096                                     {
4097                                       if (((word >> 21) & 0x1) == 0)
4098                                         {
4099                                           if (((word >> 23) & 0x1) == 0)
4100                                             {
4101                                               /* 33222222222211111111110000000000
4102                                                  10987654321098765432109876543210
4103                                                  xxxxxxxxxxxxx001xxxxx0x00x10001x
4104                                                  ld1sb.  */
4105                                               return 1519;
4106                                             }
4107                                           else
4108                                             {
4109                                               /* 33222222222211111111110000000000
4110                                                  10987654321098765432109876543210
4111                                                  xxxxxxxxxxxxx001xxxxx0x10x10001x
4112                                                  ld1sh.  */
4113                                               return 1531;
4114                                             }
4115                                         }
4116                                       else
4117                                         {
4118                                           if (((word >> 22) & 0x1) == 0)
4119                                             {
4120                                               if (((word >> 23) & 0x1) == 0)
4121                                                 {
4122                                                   /* 33222222222211111111110000000000
4123                                                      10987654321098765432109876543210
4124                                                      xxxxxxxxxxxxx001xxxxx1000x10001x
4125                                                      ld1sb.  */
4126                                                   return 1524;
4127                                                 }
4128                                               else
4129                                                 {
4130                                                   /* 33222222222211111111110000000000
4131                                                      10987654321098765432109876543210
4132                                                      xxxxxxxxxxxxx001xxxxx1010x10001x
4133                                                      ld1sh.  */
4134                                                   return 1536;
4135                                                 }
4136                                             }
4137                                           else
4138                                             {
4139                                               if (((word >> 23) & 0x1) == 0)
4140                                                 {
4141                                                   /* 33222222222211111111110000000000
4142                                                      10987654321098765432109876543210
4143                                                      xxxxxxxxxxxxx001xxxxx1100x10001x
4144                                                      prfb.  */
4145                                                   return 1706;
4146                                                 }
4147                                               else
4148                                                 {
4149                                                   /* 33222222222211111111110000000000
4150                                                      10987654321098765432109876543210
4151                                                      xxxxxxxxxxxxx001xxxxx1110x10001x
4152                                                      ld1sh.  */
4153                                                   return 1532;
4154                                                 }
4155                                             }
4156                                         }
4157                                     }
4158                                 }
4159                             }
4160                           else
4161                             {
4162                               if (((word >> 15) & 0x1) == 0)
4163                                 {
4164                                   if (((word >> 21) & 0x1) == 0)
4165                                     {
4166                                       if (((word >> 30) & 0x1) == 0)
4167                                         {
4168                                           if (((word >> 31) & 0x1) == 0)
4169                                             {
4170                                               /* 33222222222211111111110000000000
4171                                                  10987654321098765432109876543210
4172                                                  xxxxxxxxxxxxx010xxxxx0xx0x100000
4173                                                  mla.  */
4174                                               return 1679;
4175                                             }
4176                                           else
4177                                             {
4178                                               if (((word >> 23) & 0x1) == 0)
4179                                                 {
4180                                                   /* 33222222222211111111110000000000
4181                                                      10987654321098765432109876543210
4182                                                      xxxxxxxxxxxxx010xxxxx0x00x100001
4183                                                      ld1b.  */
4184                                                   return 1456;
4185                                                 }
4186                                               else
4187                                                 {
4188                                                   /* 33222222222211111111110000000000
4189                                                      10987654321098765432109876543210
4190                                                      xxxxxxxxxxxxx010xxxxx0x10x100001
4191                                                      ld1h.  */
4192                                                   return 1476;
4193                                                 }
4194                                             }
4195                                         }
4196                                       else
4197                                         {
4198                                           if (((word >> 23) & 0x1) == 0)
4199                                             {
4200                                               /* 33222222222211111111110000000000
4201                                                  10987654321098765432109876543210
4202                                                  xxxxxxxxxxxxx010xxxxx0x00x10001x
4203                                                  ld1b.  */
4204                                               return 1461;
4205                                             }
4206                                           else
4207                                             {
4208                                               /* 33222222222211111111110000000000
4209                                                  10987654321098765432109876543210
4210                                                  xxxxxxxxxxxxx010xxxxx0x10x10001x
4211                                                  ld1h.  */
4212                                               return 1481;
4213                                             }
4214                                         }
4215                                     }
4216                                   else
4217                                     {
4218                                       if (((word >> 30) & 0x1) == 0)
4219                                         {
4220                                           if (((word >> 31) & 0x1) == 0)
4221                                             {
4222                                               if (((word >> 11) & 0x1) == 0)
4223                                                 {
4224                                                   if (((word >> 12) & 0x1) == 0)
4225                                                     {
4226                                                       if (((word >> 10) & 0x1) == 0)
4227                                                         {
4228                                                           /* 33222222222211111111110000000000
4229                                                              10987654321098765432109876543210
4230                                                              xxxxxxxxxx000010xxxxx1xx0x100000
4231                                                              index.  */
4232                                                           return 1447;
4233                                                         }
4234                                                       else
4235                                                         {
4236                                                           /* 33222222222211111111110000000000
4237                                                              10987654321098765432109876543210
4238                                                              xxxxxxxxxx100010xxxxx1xx0x100000
4239                                                              index.  */
4240                                                           return 1448;
4241                                                         }
4242                                                     }
4243                                                   else
4244                                                     {
4245                                                       if (((word >> 22) & 0x1) == 0)
4246                                                         {
4247                                                           if (((word >> 23) & 0x1) == 0)
4248                                                             {
4249                                                               /* 33222222222211111111110000000000
4250                                                                  10987654321098765432109876543210
4251                                                                  xxxxxxxxxxx01010xxxxx1000x100000
4252                                                                  addvl.  */
4253                                                               return 1234;
4254                                                             }
4255                                                           else
4256                                                             {
4257                                                               /* 33222222222211111111110000000000
4258                                                                  10987654321098765432109876543210
4259                                                                  xxxxxxxxxxx01010xxxxx1010x100000
4260                                                                  rdvl.  */
4261                                                               return 1740;
4262                                                             }
4263                                                         }
4264                                                       else
4265                                                         {
4266                                                           /* 33222222222211111111110000000000
4267                                                              10987654321098765432109876543210
4268                                                              xxxxxxxxxxx01010xxxxx11x0x100000
4269                                                              addpl.  */
4270                                                           return 1233;
4271                                                         }
4272                                                     }
4273                                                 }
4274                                               else
4275                                                 {
4276                                                   if (((word >> 10) & 0x1) == 0)
4277                                                     {
4278                                                       /* 33222222222211111111110000000000
4279                                                          10987654321098765432109876543210
4280                                                          xxxxxxxxxx01x010xxxxx1xx0x100000
4281                                                          index.  */
4282                                                       return 1449;
4283                                                     }
4284                                                   else
4285                                                     {
4286                                                       /* 33222222222211111111110000000000
4287                                                          10987654321098765432109876543210
4288                                                          xxxxxxxxxx11x010xxxxx1xx0x100000
4289                                                          index.  */
4290                                                       return 1446;
4291                                                     }
4292                                                 }
4293                                             }
4294                                           else
4295                                             {
4296                                               if (((word >> 23) & 0x1) == 0)
4297                                                 {
4298                                                   /* 33222222222211111111110000000000
4299                                                      10987654321098765432109876543210
4300                                                      xxxxxxxxxxxxx010xxxxx1x00x100001
4301                                                      prfw.  */
4302                                                   return 1724;
4303                                                 }
4304                                               else
4305                                                 {
4306                                                   /* 33222222222211111111110000000000
4307                                                      10987654321098765432109876543210
4308                                                      xxxxxxxxxxxxx010xxxxx1x10x100001
4309                                                      ld1h.  */
4310                                                   return 1477;
4311                                                 }
4312                                             }
4313                                         }
4314                                       else
4315                                         {
4316                                           if (((word >> 23) & 0x1) == 0)
4317                                             {
4318                                               /* 33222222222211111111110000000000
4319                                                  10987654321098765432109876543210
4320                                                  xxxxxxxxxxxxx010xxxxx1x00x10001x
4321                                                  prfw.  */
4322                                               return 1726;
4323                                             }
4324                                           else
4325                                             {
4326                                               /* 33222222222211111111110000000000
4327                                                  10987654321098765432109876543210
4328                                                  xxxxxxxxxxxxx010xxxxx1x10x10001x
4329                                                  ld1h.  */
4330                                               return 1482;
4331                                             }
4332                                         }
4333                                     }
4334                                 }
4335                               else
4336                                 {
4337                                   if (((word >> 30) & 0x1) == 0)
4338                                     {
4339                                       if (((word >> 31) & 0x1) == 0)
4340                                         {
4341                                           if (((word >> 21) & 0x1) == 0)
4342                                             {
4343                                               /* 33222222222211111111110000000000
4344                                                  10987654321098765432109876543210
4345                                                  xxxxxxxxxxxxx011xxxxx0xx0x100000
4346                                                  mad.  */
4347                                               return 1678;
4348                                             }
4349                                           else
4350                                             {
4351                                               if (((word >> 10) & 0x1) == 0)
4352                                                 {
4353                                                   if (((word >> 11) & 0x1) == 0)
4354                                                     {
4355                                                       if (((word >> 20) & 0x1) == 0)
4356                                                         {
4357                                                           if (((word >> 22) & 0x1) == 0)
4358                                                             {
4359                                                               /* 33222222222211111111110000000000
4360                                                                  10987654321098765432109876543210
4361                                                                  xxxxxxxxxx00x011xxxx010x0x100000
4362                                                                  sqincw.  */
4363                                                               return 1798;
4364                                                             }
4365                                                           else
4366                                                             {
4367                                                               if (((word >> 23) & 0x1) == 0)
4368                                                                 {
4369                                                                   /* 33222222222211111111110000000000
4370                                                                      10987654321098765432109876543210
4371                                                                      xxxxxxxxxx00x011xxxx01100x100000
4372                                                                      sqinch.  */
4373                                                                   return 1792;
4374                                                                 }
4375                                                               else
4376                                                                 {
4377                                                                   /* 33222222222211111111110000000000
4378                                                                      10987654321098765432109876543210
4379                                                                      xxxxxxxxxx00x011xxxx01110x100000
4380                                                                      sqincd.  */
4381                                                                   return 1789;
4382                                                                 }
4383                                                             }
4384                                                         }
4385                                                       else
4386                                                         {
4387                                                           if (((word >> 22) & 0x1) == 0)
4388                                                             {
4389                                                               /* 33222222222211111111110000000000
4390                                                                  10987654321098765432109876543210
4391                                                                  xxxxxxxxxx00x011xxxx110x0x100000
4392                                                                  incw.  */
4393                                                               return 1444;
4394                                                             }
4395                                                           else
4396                                                             {
4397                                                               if (((word >> 23) & 0x1) == 0)
4398                                                                 {
4399                                                                   /* 33222222222211111111110000000000
4400                                                                      10987654321098765432109876543210
4401                                                                      xxxxxxxxxx00x011xxxx11100x100000
4402                                                                      inch.  */
4403                                                                   return 1440;
4404                                                                 }
4405                                                               else
4406                                                                 {
4407                                                                   /* 33222222222211111111110000000000
4408                                                                      10987654321098765432109876543210
4409                                                                      xxxxxxxxxx00x011xxxx11110x100000
4410                                                                      incd.  */
4411                                                                   return 1438;
4412                                                                 }
4413                                                             }
4414                                                         }
4415                                                     }
4416                                                   else
4417                                                     {
4418                                                       if (((word >> 22) & 0x1) == 0)
4419                                                         {
4420                                                           /* 33222222222211111111110000000000
4421                                                              10987654321098765432109876543210
4422                                                              xxxxxxxxxx01x011xxxxx10x0x100000
4423                                                              sqdecw.  */
4424                                                           return 1784;
4425                                                         }
4426                                                       else
4427                                                         {
4428                                                           if (((word >> 23) & 0x1) == 0)
4429                                                             {
4430                                                               /* 33222222222211111111110000000000
4431                                                                  10987654321098765432109876543210
4432                                                                  xxxxxxxxxx01x011xxxxx1100x100000
4433                                                                  sqdech.  */
4434                                                               return 1778;
4435                                                             }
4436                                                           else
4437                                                             {
4438                                                               /* 33222222222211111111110000000000
4439                                                                  10987654321098765432109876543210
4440                                                                  xxxxxxxxxx01x011xxxxx1110x100000
4441                                                                  sqdecd.  */
4442                                                               return 1775;
4443                                                             }
4444                                                         }
4445                                                     }
4446                                                 }
4447                                               else
4448                                                 {
4449                                                   if (((word >> 11) & 0x1) == 0)
4450                                                     {
4451                                                       if (((word >> 20) & 0x1) == 0)
4452                                                         {
4453                                                           if (((word >> 22) & 0x1) == 0)
4454                                                             {
4455                                                               /* 33222222222211111111110000000000
4456                                                                  10987654321098765432109876543210
4457                                                                  xxxxxxxxxx10x011xxxx010x0x100000
4458                                                                  uqincw.  */
4459                                                               return 1946;
4460                                                             }
4461                                                           else
4462                                                             {
4463                                                               if (((word >> 23) & 0x1) == 0)
4464                                                                 {
4465                                                                   /* 33222222222211111111110000000000
4466                                                                      10987654321098765432109876543210
4467                                                                      xxxxxxxxxx10x011xxxx01100x100000
4468                                                                      uqinch.  */
4469                                                                   return 1940;
4470                                                                 }
4471                                                               else
4472                                                                 {
4473                                                                   /* 33222222222211111111110000000000
4474                                                                      10987654321098765432109876543210
4475                                                                      xxxxxxxxxx10x011xxxx01110x100000
4476                                                                      uqincd.  */
4477                                                                   return 1937;
4478                                                                 }
4479                                                             }
4480                                                         }
4481                                                       else
4482                                                         {
4483                                                           if (((word >> 22) & 0x1) == 0)
4484                                                             {
4485                                                               /* 33222222222211111111110000000000
4486                                                                  10987654321098765432109876543210
4487                                                                  xxxxxxxxxx10x011xxxx110x0x100000
4488                                                                  decw.  */
4489                                                               return 1319;
4490                                                             }
4491                                                           else
4492                                                             {
4493                                                               if (((word >> 23) & 0x1) == 0)
4494                                                                 {
4495                                                                   /* 33222222222211111111110000000000
4496                                                                      10987654321098765432109876543210
4497                                                                      xxxxxxxxxx10x011xxxx11100x100000
4498                                                                      dech.  */
4499                                                                   return 1315;
4500                                                                 }
4501                                                               else
4502                                                                 {
4503                                                                   /* 33222222222211111111110000000000
4504                                                                      10987654321098765432109876543210
4505                                                                      xxxxxxxxxx10x011xxxx11110x100000
4506                                                                      decd.  */
4507                                                                   return 1313;
4508                                                                 }
4509                                                             }
4510                                                         }
4511                                                     }
4512                                                   else
4513                                                     {
4514                                                       if (((word >> 22) & 0x1) == 0)
4515                                                         {
4516                                                           /* 33222222222211111111110000000000
4517                                                              10987654321098765432109876543210
4518                                                              xxxxxxxxxx11x011xxxxx10x0x100000
4519                                                              uqdecw.  */
4520                                                           return 1932;
4521                                                         }
4522                                                       else
4523                                                         {
4524                                                           if (((word >> 23) & 0x1) == 0)
4525                                                             {
4526                                                               /* 33222222222211111111110000000000
4527                                                                  10987654321098765432109876543210
4528                                                                  xxxxxxxxxx11x011xxxxx1100x100000
4529                                                                  uqdech.  */
4530                                                               return 1926;
4531                                                             }
4532                                                           else
4533                                                             {
4534                                                               /* 33222222222211111111110000000000
4535                                                                  10987654321098765432109876543210
4536                                                                  xxxxxxxxxx11x011xxxxx1110x100000
4537                                                                  uqdecd.  */
4538                                                               return 1923;
4539                                                             }
4540                                                         }
4541                                                     }
4542                                                 }
4543                                             }
4544                                         }
4545                                       else
4546                                         {
4547                                           if (((word >> 22) & 0x1) == 0)
4548                                             {
4549                                               if (((word >> 21) & 0x1) == 0)
4550                                                 {
4551                                                   if (((word >> 23) & 0x1) == 0)
4552                                                     {
4553                                                       /* 33222222222211111111110000000000
4554                                                          10987654321098765432109876543210
4555                                                          xxxxxxxxxxxxx011xxxxx0000x100001
4556                                                          prfb.  */
4557                                                       return 1703;
4558                                                     }
4559                                                   else
4560                                                     {
4561                                                       /* 33222222222211111111110000000000
4562                                                          10987654321098765432109876543210
4563                                                          xxxxxxxxxxxxx011xxxxx0010x100001
4564                                                          prfh.  */
4565                                                       return 1718;
4566                                                     }
4567                                                 }
4568                                               else
4569                                                 {
4570                                                   if (((word >> 23) & 0x1) == 0)
4571                                                     {
4572                                                       /* 33222222222211111111110000000000
4573                                                          10987654321098765432109876543210
4574                                                          xxxxxxxxxxxxx011xxxxx1000x100001
4575                                                          ld1b.  */
4576                                                       return 1463;
4577                                                     }
4578                                                   else
4579                                                     {
4580                                                       /* 33222222222211111111110000000000
4581                                                          10987654321098765432109876543210
4582                                                          xxxxxxxxxxxxx011xxxxx1010x100001
4583                                                          ld1h.  */
4584                                                       return 1485;
4585                                                     }
4586                                                 }
4587                                             }
4588                                           else
4589                                             {
4590                                               if (((word >> 23) & 0x1) == 0)
4591                                                 {
4592                                                   /* 33222222222211111111110000000000
4593                                                      10987654321098765432109876543210
4594                                                      xxxxxxxxxxxxx011xxxxxx100x100001
4595                                                      ld1rb.  */
4596                                                   return 1492;
4597                                                 }
4598                                               else
4599                                                 {
4600                                                   /* 33222222222211111111110000000000
4601                                                      10987654321098765432109876543210
4602                                                      xxxxxxxxxxxxx011xxxxxx110x100001
4603                                                      ld1rh.  */
4604                                                   return 1496;
4605                                                 }
4606                                             }
4607                                         }
4608                                     }
4609                                   else
4610                                     {
4611                                       if (((word >> 21) & 0x1) == 0)
4612                                         {
4613                                           if (((word >> 23) & 0x1) == 0)
4614                                             {
4615                                               /* 33222222222211111111110000000000
4616                                                  10987654321098765432109876543210
4617                                                  xxxxxxxxxxxxx011xxxxx0x00x10001x
4618                                                  ld1b.  */
4619                                               return 1462;
4620                                             }
4621                                           else
4622                                             {
4623                                               /* 33222222222211111111110000000000
4624                                                  10987654321098765432109876543210
4625                                                  xxxxxxxxxxxxx011xxxxx0x10x10001x
4626                                                  ld1h.  */
4627                                               return 1483;
4628                                             }
4629                                         }
4630                                       else
4631                                         {
4632                                           if (((word >> 22) & 0x1) == 0)
4633                                             {
4634                                               if (((word >> 23) & 0x1) == 0)
4635                                                 {
4636                                                   /* 33222222222211111111110000000000
4637                                                      10987654321098765432109876543210
4638                                                      xxxxxxxxxxxxx011xxxxx1000x10001x
4639                                                      ld1b.  */
4640                                                   return 1468;
4641                                                 }
4642                                               else
4643                                                 {
4644                                                   /* 33222222222211111111110000000000
4645                                                      10987654321098765432109876543210
4646                                                      xxxxxxxxxxxxx011xxxxx1010x10001x
4647                                                      ld1h.  */
4648                                                   return 1489;
4649                                                 }
4650                                             }
4651                                           else
4652                                             {
4653                                               if (((word >> 23) & 0x1) == 0)
4654                                                 {
4655                                                   /* 33222222222211111111110000000000
4656                                                      10987654321098765432109876543210
4657                                                      xxxxxxxxxxxxx011xxxxx1100x10001x
4658                                                      prfw.  */
4659                                                   return 1727;
4660                                                 }
4661                                               else
4662                                                 {
4663                                                   /* 33222222222211111111110000000000
4664                                                      10987654321098765432109876543210
4665                                                      xxxxxxxxxxxxx011xxxxx1110x10001x
4666                                                      ld1h.  */
4667                                                   return 1484;
4668                                                 }
4669                                             }
4670                                         }
4671                                     }
4672                                 }
4673                             }
4674                         }
4675                       else
4676                         {
4677                           if (((word >> 14) & 0x1) == 0)
4678                             {
4679                               if (((word >> 15) & 0x1) == 0)
4680                                 {
4681                                   if (((word >> 21) & 0x1) == 0)
4682                                     {
4683                                       if (((word >> 30) & 0x1) == 0)
4684                                         {
4685                                           if (((word >> 31) & 0x1) == 0)
4686                                             {
4687                                               if (((word >> 17) & 0x1) == 0)
4688                                                 {
4689                                                   if (((word >> 19) & 0x1) == 0)
4690                                                     {
4691                                                       if (((word >> 20) & 0x1) == 0)
4692                                                         {
4693                                                           if (((word >> 16) & 0x1) == 0)
4694                                                             {
4695                                                               /* 33222222222211111111110000000000
4696                                                                  10987654321098765432109876543210
4697                                                                  xxxxxxxxxxxxx10000x000xx0x100000
4698                                                                  saddv.  */
4699                                                               return 1747;
4700                                                             }
4701                                                           else
4702                                                             {
4703                                                               /* 33222222222211111111110000000000
4704                                                                  10987654321098765432109876543210
4705                                                                  xxxxxxxxxxxxx10010x000xx0x100000
4706                                                                  uaddv.  */
4707                                                               return 1899;
4708                                                             }
4709                                                         }
4710                                                       else
4711                                                         {
4712                                                           /* 33222222222211111111110000000000
4713                                                              10987654321098765432109876543210
4714                                                              xxxxxxxxxxxxx100x0x010xx0x100000
4715                                                              movprfx.  */
4716                                                           return 1682;
4717                                                         }
4718                                                     }
4719                                                   else
4720                                                     {
4721                                                       if (((word >> 16) & 0x1) == 0)
4722                                                         {
4723                                                           if (((word >> 20) & 0x1) == 0)
4724                                                             {
4725                                                               /* 33222222222211111111110000000000
4726                                                                  10987654321098765432109876543210
4727                                                                  xxxxxxxxxxxxx10000x100xx0x100000
4728                                                                  smaxv.  */
4729                                                               return 1765;
4730                                                             }
4731                                                           else
4732                                                             {
4733                                                               /* 33222222222211111111110000000000
4734                                                                  10987654321098765432109876543210
4735                                                                  xxxxxxxxxxxxx10000x110xx0x100000
4736                                                                  orv.  */
4737                                                               return 1699;
4738                                                             }
4739                                                         }
4740                                                       else
4741                                                         {
4742                                                           if (((word >> 20) & 0x1) == 0)
4743                                                             {
4744                                                               /* 33222222222211111111110000000000
4745                                                                  10987654321098765432109876543210
4746                                                                  xxxxxxxxxxxxx10010x100xx0x100000
4747                                                                  umaxv.  */
4748                                                               return 1914;
4749                                                             }
4750                                                           else
4751                                                             {
4752                                                               /* 33222222222211111111110000000000
4753                                                                  10987654321098765432109876543210
4754                                                                  xxxxxxxxxxxxx10010x110xx0x100000
4755                                                                  eorv.  */
4756                                                               return 1330;
4757                                                             }
4758                                                         }
4759                                                     }
4760                                                 }
4761                                               else
4762                                                 {
4763                                                   if (((word >> 16) & 0x1) == 0)
4764                                                     {
4765                                                       if (((word >> 20) & 0x1) == 0)
4766                                                         {
4767                                                           /* 33222222222211111111110000000000
4768                                                              10987654321098765432109876543210
4769                                                              xxxxxxxxxxxxx10001xx00xx0x100000
4770                                                              sminv.  */
4771                                                           return 1768;
4772                                                         }
4773                                                       else
4774                                                         {
4775                                                           /* 33222222222211111111110000000000
4776                                                              10987654321098765432109876543210
4777                                                              xxxxxxxxxxxxx10001xx10xx0x100000
4778                                                              andv.  */
4779                                                           return 1243;
4780                                                         }
4781                                                     }
4782                                                   else
4783                                                     {
4784                                                       /* 33222222222211111111110000000000
4785                                                          10987654321098765432109876543210
4786                                                          xxxxxxxxxxxxx10011xxx0xx0x100000
4787                                                          uminv.  */
4788                                                       return 1917;
4789                                                     }
4790                                                 }
4791                                             }
4792                                           else
4793                                             {
4794                                               if (((word >> 23) & 0x1) == 0)
4795                                                 {
4796                                                   /* 33222222222211111111110000000000
4797                                                      10987654321098765432109876543210
4798                                                      xxxxxxxxxxxxx100xxxxx0x00x100001
4799                                                      ldff1sb.  */
4800                                                   return 1606;
4801                                                 }
4802                                               else
4803                                                 {
4804                                                   /* 33222222222211111111110000000000
4805                                                      10987654321098765432109876543210
4806                                                      xxxxxxxxxxxxx100xxxxx0x10x100001
4807                                                      ldff1sh.  */
4808                                                   return 1614;
4809                                                 }
4810                                             }
4811                                         }
4812                                       else
4813                                         {
4814                                           if (((word >> 23) & 0x1) == 0)
4815                                             {
4816                                               /* 33222222222211111111110000000000
4817                                                  10987654321098765432109876543210
4818                                                  xxxxxxxxxxxxx100xxxxx0x00x10001x
4819                                                  ldff1sb.  */
4820                                               return 1610;
4821                                             }
4822                                           else
4823                                             {
4824                                               /* 33222222222211111111110000000000
4825                                                  10987654321098765432109876543210
4826                                                  xxxxxxxxxxxxx100xxxxx0x10x10001x
4827                                                  ldff1sh.  */
4828                                               return 1618;
4829                                             }
4830                                         }
4831                                     }
4832                                   else
4833                                     {
4834                                       if (((word >> 23) & 0x1) == 0)
4835                                         {
4836                                           if (((word >> 30) & 0x1) == 0)
4837                                             {
4838                                               if (((word >> 31) & 0x1) == 0)
4839                                                 {
4840                                                   if (((word >> 22) & 0x1) == 0)
4841                                                     {
4842                                                       /* 33222222222211111111110000000000
4843                                                          10987654321098765432109876543210
4844                                                          xxxxxxxxxxxxx100xxxxx1000x100000
4845                                                          and.  */
4846                                                       return 1238;
4847                                                     }
4848                                                   else
4849                                                     {
4850                                                       /* 33222222222211111111110000000000
4851                                                          10987654321098765432109876543210
4852                                                          xxxxxxxxxxxxx100xxxxx1100x100000
4853                                                          orr.  */
4854                                                       return 1694;
4855                                                     }
4856                                                 }
4857                                               else
4858                                                 {
4859                                                   /* 33222222222211111111110000000000
4860                                                      10987654321098765432109876543210
4861                                                      xxxxxxxxxxxxx100xxxxx1x00x100001
4862                                                      prfh.  */
4863                                                   return 1717;
4864                                                 }
4865                                             }
4866                                           else
4867                                             {
4868                                               /* 33222222222211111111110000000000
4869                                                  10987654321098765432109876543210
4870                                                  xxxxxxxxxxxxx100xxxxx1x00x10001x
4871                                                  prfh.  */
4872                                               return 1719;
4873                                             }
4874                                         }
4875                                       else
4876                                         {
4877                                           if (((word >> 30) & 0x1) == 0)
4878                                             {
4879                                               if (((word >> 31) & 0x1) == 0)
4880                                                 {
4881                                                   if (((word >> 22) & 0x1) == 0)
4882                                                     {
4883                                                       /* 33222222222211111111110000000000
4884                                                          10987654321098765432109876543210
4885                                                          xxxxxxxxxxxxx100xxxxx1010x100000
4886                                                          eor.  */
4887                                                       return 1325;
4888                                                     }
4889                                                   else
4890                                                     {
4891                                                       /* 33222222222211111111110000000000
4892                                                          10987654321098765432109876543210
4893                                                          xxxxxxxxxxxxx100xxxxx1110x100000
4894                                                          bic.  */
4895                                                       return 1251;
4896                                                     }
4897                                                 }
4898                                               else
4899                                                 {
4900                                                   /* 33222222222211111111110000000000
4901                                                      10987654321098765432109876543210
4902                                                      xxxxxxxxxxxxx100xxxxx1x10x100001
4903                                                      ldff1sh.  */
4904                                                   return 1615;
4905                                                 }
4906                                             }
4907                                           else
4908                                             {
4909                                               /* 33222222222211111111110000000000
4910                                                  10987654321098765432109876543210
4911                                                  xxxxxxxxxxxxx100xxxxx1x10x10001x
4912                                                  ldff1sh.  */
4913                                               return 1619;
4914                                             }
4915                                         }
4916                                     }
4917                                 }
4918                               else
4919                                 {
4920                                   if (((word >> 30) & 0x1) == 0)
4921                                     {
4922                                       if (((word >> 31) & 0x1) == 0)
4923                                         {
4924                                           if (((word >> 21) & 0x1) == 0)
4925                                             {
4926                                               if (((word >> 16) & 0x1) == 0)
4927                                                 {
4928                                                   if (((word >> 17) & 0x1) == 0)
4929                                                     {
4930                                                       if (((word >> 18) & 0x1) == 0)
4931                                                         {
4932                                                           if (((word >> 19) & 0x1) == 0)
4933                                                             {
4934                                                               /* 33222222222211111111110000000000
4935                                                                  10987654321098765432109876543210
4936                                                                  xxxxxxxxxxxxx1010000x0xx0x100000
4937                                                                  sxtb.  */
4938                                                               return 1890;
4939                                                             }
4940                                                           else
4941                                                             {
4942                                                               /* 33222222222211111111110000000000
4943                                                                  10987654321098765432109876543210
4944                                                                  xxxxxxxxxxxxx1010001x0xx0x100000
4945                                                                  cls.  */
4946                                                               return 1271;
4947                                                             }
4948                                                         }
4949                                                       else
4950                                                         {
4951                                                           if (((word >> 19) & 0x1) == 0)
4952                                                             {
4953                                                               /* 33222222222211111111110000000000
4954                                                                  10987654321098765432109876543210
4955                                                                  xxxxxxxxxxxxx1010010x0xx0x100000
4956                                                                  sxtw.  */
4957                                                               return 1892;
4958                                                             }
4959                                                           else
4960                                                             {
4961                                                               /* 33222222222211111111110000000000
4962                                                                  10987654321098765432109876543210
4963                                                                  xxxxxxxxxxxxx1010011x0xx0x100000
4964                                                                  fabs.  */
4965                                                               return 1333;
4966                                                             }
4967                                                         }
4968                                                     }
4969                                                   else
4970                                                     {
4971                                                       if (((word >> 18) & 0x1) == 0)
4972                                                         {
4973                                                           if (((word >> 19) & 0x1) == 0)
4974                                                             {
4975                                                               /* 33222222222211111111110000000000
4976                                                                  10987654321098765432109876543210
4977                                                                  xxxxxxxxxxxxx1010100x0xx0x100000
4978                                                                  sxth.  */
4979                                                               return 1891;
4980                                                             }
4981                                                           else
4982                                                             {
4983                                                               /* 33222222222211111111110000000000
4984                                                                  10987654321098765432109876543210
4985                                                                  xxxxxxxxxxxxx1010101x0xx0x100000
4986                                                                  cnt.  */
4987                                                               return 1300;
4988                                                             }
4989                                                         }
4990                                                       else
4991                                                         {
4992                                                           if (((word >> 19) & 0x1) == 0)
4993                                                             {
4994                                                               /* 33222222222211111111110000000000
4995                                                                  10987654321098765432109876543210
4996                                                                  xxxxxxxxxxxxx1010110x0xx0x100000
4997                                                                  abs.  */
4998                                                               return 1229;
4999                                                             }
5000                                                           else
5001                                                             {
5002                                                               /* 33222222222211111111110000000000
5003                                                                  10987654321098765432109876543210
5004                                                                  xxxxxxxxxxxxx1010111x0xx0x100000
5005                                                                  not.  */
5006                                                               return 1691;
5007                                                             }
5008                                                         }
5009                                                     }
5010                                                 }
5011                                               else
5012                                                 {
5013                                                   if (((word >> 17) & 0x1) == 0)
5014                                                     {
5015                                                       if (((word >> 18) & 0x1) == 0)
5016                                                         {
5017                                                           if (((word >> 19) & 0x1) == 0)
5018                                                             {
5019                                                               /* 33222222222211111111110000000000
5020                                                                  10987654321098765432109876543210
5021                                                                  xxxxxxxxxxxxx1011000x0xx0x100000
5022                                                                  uxtb.  */
5023                                                               return 1953;
5024                                                             }
5025                                                           else
5026                                                             {
5027                                                               /* 33222222222211111111110000000000
5028                                                                  10987654321098765432109876543210
5029                                                                  xxxxxxxxxxxxx1011001x0xx0x100000
5030                                                                  clz.  */
5031                                                               return 1272;
5032                                                             }
5033                                                         }
5034                                                       else
5035                                                         {
5036                                                           if (((word >> 19) & 0x1) == 0)
5037                                                             {
5038                                                               /* 33222222222211111111110000000000
5039                                                                  10987654321098765432109876543210
5040                                                                  xxxxxxxxxxxxx1011010x0xx0x100000
5041                                                                  uxtw.  */
5042                                                               return 1955;
5043                                                             }
5044                                                           else
5045                                                             {
5046                                                               /* 33222222222211111111110000000000
5047                                                                  10987654321098765432109876543210
5048                                                                  xxxxxxxxxxxxx1011011x0xx0x100000
5049                                                                  fneg.  */
5050                                                               return 1410;
5051                                                             }
5052                                                         }
5053                                                     }
5054                                                   else
5055                                                     {
5056                                                       if (((word >> 18) & 0x1) == 0)
5057                                                         {
5058                                                           if (((word >> 19) & 0x1) == 0)
5059                                                             {
5060                                                               /* 33222222222211111111110000000000
5061                                                                  10987654321098765432109876543210
5062                                                                  xxxxxxxxxxxxx1011100x0xx0x100000
5063                                                                  uxth.  */
5064                                                               return 1954;
5065                                                             }
5066                                                           else
5067                                                             {
5068                                                               /* 33222222222211111111110000000000
5069                                                                  10987654321098765432109876543210
5070                                                                  xxxxxxxxxxxxx1011101x0xx0x100000
5071                                                                  cnot.  */
5072                                                               return 1299;
5073                                                             }
5074                                                         }
5075                                                       else
5076                                                         {
5077                                                           /* 33222222222211111111110000000000
5078                                                              10987654321098765432109876543210
5079                                                              xxxxxxxxxxxxx101111xx0xx0x100000
5080                                                              neg.  */
5081                                                           return 1688;
5082                                                         }
5083                                                     }
5084                                                 }
5085                                             }
5086                                           else
5087                                             {
5088                                               if (((word >> 12) & 0x1) == 0)
5089                                                 {
5090                                                   if (((word >> 23) & 0x1) == 0)
5091                                                     {
5092                                                       if (((word >> 22) & 0x1) == 0)
5093                                                         {
5094                                                           /* 33222222222211111111110000000000
5095                                                              10987654321098765432109876543210
5096                                                              xxxxxxxxxxxx0101xxxxx1000x100000
5097                                                              adr.  */
5098                                                           return 1235;
5099                                                         }
5100                                                       else
5101                                                         {
5102                                                           /* 33222222222211111111110000000000
5103                                                              10987654321098765432109876543210
5104                                                              xxxxxxxxxxxx0101xxxxx1100x100000
5105                                                              adr.  */
5106                                                           return 1236;
5107                                                         }
5108                                                     }
5109                                                   else
5110                                                     {
5111                                                       /* 33222222222211111111110000000000
5112                                                          10987654321098765432109876543210
5113                                                          xxxxxxxxxxxx0101xxxxx1x10x100000
5114                                                          adr.  */
5115                                                       return 1237;
5116                                                     }
5117                                                 }
5118                                               else
5119                                                 {
5120                                                   if (((word >> 10) & 0x1) == 0)
5121                                                     {
5122                                                       if (((word >> 11) & 0x1) == 0)
5123                                                         {
5124                                                           /* 33222222222211111111110000000000
5125                                                              10987654321098765432109876543210
5126                                                              xxxxxxxxxx001101xxxxx1xx0x100000
5127                                                              ftssel.  */
5128                                                           return 1436;
5129                                                         }
5130                                                       else
5131                                                         {
5132                                                           /* 33222222222211111111110000000000
5133                                                              10987654321098765432109876543210
5134                                                              xxxxxxxxxx011101xxxxx1xx0x100000
5135                                                              fexpa.  */
5136                                                           return 1380;
5137                                                         }
5138                                                     }
5139                                                   else
5140                                                     {
5141                                                       /* 33222222222211111111110000000000
5142                                                          10987654321098765432109876543210
5143                                                          xxxxxxxxxx1x1101xxxxx1xx0x100000
5144                                                          movprfx.  */
5145                                                       return 1681;
5146                                                     }
5147                                                 }
5148                                             }
5149                                         }
5150                                       else
5151                                         {
5152                                           if (((word >> 22) & 0x1) == 0)
5153                                             {
5154                                               if (((word >> 23) & 0x1) == 0)
5155                                                 {
5156                                                   /* 33222222222211111111110000000000
5157                                                      10987654321098765432109876543210
5158                                                      xxxxxxxxxxxxx101xxxxxx000x100001
5159                                                      ldff1sb.  */
5160                                                   return 1612;
5161                                                 }
5162                                               else
5163                                                 {
5164                                                   /* 33222222222211111111110000000000
5165                                                      10987654321098765432109876543210
5166                                                      xxxxxxxxxxxxx101xxxxxx010x100001
5167                                                      ldff1sh.  */
5168                                                   return 1622;
5169                                                 }
5170                                             }
5171                                           else
5172                                             {
5173                                               if (((word >> 23) & 0x1) == 0)
5174                                                 {
5175                                                   /* 33222222222211111111110000000000
5176                                                      10987654321098765432109876543210
5177                                                      xxxxxxxxxxxxx101xxxxxx100x100001
5178                                                      ld1rb.  */
5179                                                   return 1491;
5180                                                 }
5181                                               else
5182                                                 {
5183                                                   /* 33222222222211111111110000000000
5184                                                      10987654321098765432109876543210
5185                                                      xxxxxxxxxxxxx101xxxxxx110x100001
5186                                                      ld1rh.  */
5187                                                   return 1495;
5188                                                 }
5189                                             }
5190                                         }
5191                                     }
5192                                   else
5193                                     {
5194                                       if (((word >> 21) & 0x1) == 0)
5195                                         {
5196                                           if (((word >> 23) & 0x1) == 0)
5197                                             {
5198                                               /* 33222222222211111111110000000000
5199                                                  10987654321098765432109876543210
5200                                                  xxxxxxxxxxxxx101xxxxx0x00x10001x
5201                                                  ldff1sb.  */
5202                                               return 1611;
5203                                             }
5204                                           else
5205                                             {
5206                                               /* 33222222222211111111110000000000
5207                                                  10987654321098765432109876543210
5208                                                  xxxxxxxxxxxxx101xxxxx0x10x10001x
5209                                                  ldff1sh.  */
5210                                               return 1620;
5211                                             }
5212                                         }
5213                                       else
5214                                         {
5215                                           if (((word >> 22) & 0x1) == 0)
5216                                             {
5217                                               if (((word >> 23) & 0x1) == 0)
5218                                                 {
5219                                                   /* 33222222222211111111110000000000
5220                                                      10987654321098765432109876543210
5221                                                      xxxxxxxxxxxxx101xxxxx1000x10001x
5222                                                      ldff1sb.  */
5223                                                   return 1613;
5224                                                 }
5225                                               else
5226                                                 {
5227                                                   /* 33222222222211111111110000000000
5228                                                      10987654321098765432109876543210
5229                                                      xxxxxxxxxxxxx101xxxxx1010x10001x
5230                                                      ldff1sh.  */
5231                                                   return 1623;
5232                                                 }
5233                                             }
5234                                           else
5235                                             {
5236                                               if (((word >> 23) & 0x1) == 0)
5237                                                 {
5238                                                   /* 33222222222211111111110000000000
5239                                                      10987654321098765432109876543210
5240                                                      xxxxxxxxxxxxx101xxxxx1100x10001x
5241                                                      prfh.  */
5242                                                   return 1720;
5243                                                 }
5244                                               else
5245                                                 {
5246                                                   /* 33222222222211111111110000000000
5247                                                      10987654321098765432109876543210
5248                                                      xxxxxxxxxxxxx101xxxxx1110x10001x
5249                                                      ldff1sh.  */
5250                                                   return 1621;
5251                                                 }
5252                                             }
5253                                         }
5254                                     }
5255                                 }
5256                             }
5257                           else
5258                             {
5259                               if (((word >> 15) & 0x1) == 0)
5260                                 {
5261                                   if (((word >> 21) & 0x1) == 0)
5262                                     {
5263                                       if (((word >> 30) & 0x1) == 0)
5264                                         {
5265                                           if (((word >> 31) & 0x1) == 0)
5266                                             {
5267                                               /* 33222222222211111111110000000000
5268                                                  10987654321098765432109876543210
5269                                                  xxxxxxxxxxxxx110xxxxx0xx0x100000
5270                                                  mls.  */
5271                                               return 1680;
5272                                             }
5273                                           else
5274                                             {
5275                                               if (((word >> 23) & 0x1) == 0)
5276                                                 {
5277                                                   /* 33222222222211111111110000000000
5278                                                      10987654321098765432109876543210
5279                                                      xxxxxxxxxxxxx110xxxxx0x00x100001
5280                                                      ldff1b.  */
5281                                                   return 1580;
5282                                                 }
5283                                               else
5284                                                 {
5285                                                   /* 33222222222211111111110000000000
5286                                                      10987654321098765432109876543210
5287                                                      xxxxxxxxxxxxx110xxxxx0x10x100001
5288                                                      ldff1h.  */
5289                                                   return 1595;
5290                                                 }
5291                                             }
5292                                         }
5293                                       else
5294                                         {
5295                                           if (((word >> 23) & 0x1) == 0)
5296                                             {
5297                                               /* 33222222222211111111110000000000
5298                                                  10987654321098765432109876543210
5299                                                  xxxxxxxxxxxxx110xxxxx0x00x10001x
5300                                                  ldff1b.  */
5301                                               return 1585;
5302                                             }
5303                                           else
5304                                             {
5305                                               /* 33222222222211111111110000000000
5306                                                  10987654321098765432109876543210
5307                                                  xxxxxxxxxxxxx110xxxxx0x10x10001x
5308                                                  ldff1h.  */
5309                                               return 1600;
5310                                             }
5311                                         }
5312                                     }
5313                                   else
5314                                     {
5315                                       if (((word >> 23) & 0x1) == 0)
5316                                         {
5317                                           if (((word >> 30) & 0x1) == 0)
5318                                             {
5319                                               /* 33222222222211111111110000000000
5320                                                  10987654321098765432109876543210
5321                                                  xxxxxxxxxxxxx110xxxxx1x00x10000x
5322                                                  prfd.  */
5323                                               return 1710;
5324                                             }
5325                                           else
5326                                             {
5327                                               /* 33222222222211111111110000000000
5328                                                  10987654321098765432109876543210
5329                                                  xxxxxxxxxxxxx110xxxxx1x00x10001x
5330                                                  prfd.  */
5331                                               return 1712;
5332                                             }
5333                                         }
5334                                       else
5335                                         {
5336                                           if (((word >> 30) & 0x1) == 0)
5337                                             {
5338                                               /* 33222222222211111111110000000000
5339                                                  10987654321098765432109876543210
5340                                                  xxxxxxxxxxxxx110xxxxx1x10x10000x
5341                                                  ldff1h.  */
5342                                               return 1596;
5343                                             }
5344                                           else
5345                                             {
5346                                               /* 33222222222211111111110000000000
5347                                                  10987654321098765432109876543210
5348                                                  xxxxxxxxxxxxx110xxxxx1x10x10001x
5349                                                  ldff1h.  */
5350                                               return 1601;
5351                                             }
5352                                         }
5353                                     }
5354                                 }
5355                               else
5356                                 {
5357                                   if (((word >> 30) & 0x1) == 0)
5358                                     {
5359                                       if (((word >> 31) & 0x1) == 0)
5360                                         {
5361                                           if (((word >> 21) & 0x1) == 0)
5362                                             {
5363                                               /* 33222222222211111111110000000000
5364                                                  10987654321098765432109876543210
5365                                                  xxxxxxxxxxxxx111xxxxx0xx0x100000
5366                                                  msb.  */
5367                                               return 1683;
5368                                             }
5369                                           else
5370                                             {
5371                                               if (((word >> 10) & 0x1) == 0)
5372                                                 {
5373                                                   if (((word >> 11) & 0x1) == 0)
5374                                                     {
5375                                                       if (((word >> 12) & 0x1) == 0)
5376                                                         {
5377                                                           if (((word >> 20) & 0x1) == 0)
5378                                                             {
5379                                                               if (((word >> 22) & 0x1) == 0)
5380                                                                 {
5381                                                                   if (((word >> 23) & 0x1) == 0)
5382                                                                     {
5383                                                                       /* 33222222222211111111110000000000
5384                                                                          10987654321098765432109876543210
5385                                                                          xxxxxxxxxx000111xxxx01000x100000
5386                                                                          cntb.  */
5387                                                                       return 1301;
5388                                                                     }
5389                                                                   else
5390                                                                     {
5391                                                                       /* 33222222222211111111110000000000
5392                                                                          10987654321098765432109876543210
5393                                                                          xxxxxxxxxx000111xxxx01010x100000
5394                                                                          cntw.  */
5395                                                                       return 1305;
5396                                                                     }
5397                                                                 }
5398                                                               else
5399                                                                 {
5400                                                                   if (((word >> 23) & 0x1) == 0)
5401                                                                     {
5402                                                                       /* 33222222222211111111110000000000
5403                                                                          10987654321098765432109876543210
5404                                                                          xxxxxxxxxx000111xxxx01100x100000
5405                                                                          cnth.  */
5406                                                                       return 1303;
5407                                                                     }
5408                                                                   else
5409                                                                     {
5410                                                                       /* 33222222222211111111110000000000
5411                                                                          10987654321098765432109876543210
5412                                                                          xxxxxxxxxx000111xxxx01110x100000
5413                                                                          cntd.  */
5414                                                                       return 1302;
5415                                                                     }
5416                                                                 }
5417                                                             }
5418                                                           else
5419                                                             {
5420                                                               if (((word >> 22) & 0x1) == 0)
5421                                                                 {
5422                                                                   if (((word >> 23) & 0x1) == 0)
5423                                                                     {
5424                                                                       /* 33222222222211111111110000000000
5425                                                                          10987654321098765432109876543210
5426                                                                          xxxxxxxxxx000111xxxx11000x100000
5427                                                                          incb.  */
5428                                                                       return 1437;
5429                                                                     }
5430                                                                   else
5431                                                                     {
5432                                                                       /* 33222222222211111111110000000000
5433                                                                          10987654321098765432109876543210
5434                                                                          xxxxxxxxxx000111xxxx11010x100000
5435                                                                          incw.  */
5436                                                                       return 1445;
5437                                                                     }
5438                                                                 }
5439                                                               else
5440                                                                 {
5441                                                                   if (((word >> 23) & 0x1) == 0)
5442                                                                     {
5443                                                                       /* 33222222222211111111110000000000
5444                                                                          10987654321098765432109876543210
5445                                                                          xxxxxxxxxx000111xxxx11100x100000
5446                                                                          inch.  */
5447                                                                       return 1441;
5448                                                                     }
5449                                                                   else
5450                                                                     {
5451                                                                       /* 33222222222211111111110000000000
5452                                                                          10987654321098765432109876543210
5453                                                                          xxxxxxxxxx000111xxxx11110x100000
5454                                                                          incd.  */
5455                                                                       return 1439;
5456                                                                     }
5457                                                                 }
5458                                                             }
5459                                                         }
5460                                                       else
5461                                                         {
5462                                                           if (((word >> 20) & 0x1) == 0)
5463                                                             {
5464                                                               if (((word >> 22) & 0x1) == 0)
5465                                                                 {
5466                                                                   if (((word >> 23) & 0x1) == 0)
5467                                                                     {
5468                                                                       /* 33222222222211111111110000000000
5469                                                                          10987654321098765432109876543210
5470                                                                          xxxxxxxxxx001111xxxx01000x100000
5471                                                                          sqincb.  */
5472                                                                       return 1788;
5473                                                                     }
5474                                                                   else
5475                                                                     {
5476                                                                       /* 33222222222211111111110000000000
5477                                                                          10987654321098765432109876543210
5478                                                                          xxxxxxxxxx001111xxxx01010x100000
5479                                                                          sqincw.  */
5480                                                                       return 1800;
5481                                                                     }
5482                                                                 }
5483                                                               else
5484                                                                 {
5485                                                                   if (((word >> 23) & 0x1) == 0)
5486                                                                     {
5487                                                                       /* 33222222222211111111110000000000
5488                                                                          10987654321098765432109876543210
5489                                                                          xxxxxxxxxx001111xxxx01100x100000
5490                                                                          sqinch.  */
5491                                                                       return 1794;
5492                                                                     }
5493                                                                   else
5494                                                                     {
5495                                                                       /* 33222222222211111111110000000000
5496                                                                          10987654321098765432109876543210
5497                                                                          xxxxxxxxxx001111xxxx01110x100000
5498                                                                          sqincd.  */
5499                                                                       return 1791;
5500                                                                     }
5501                                                                 }
5502                                                             }
5503                                                           else
5504                                                             {
5505                                                               if (((word >> 22) & 0x1) == 0)
5506                                                                 {
5507                                                                   if (((word >> 23) & 0x1) == 0)
5508                                                                     {
5509                                                                       /* 33222222222211111111110000000000
5510                                                                          10987654321098765432109876543210
5511                                                                          xxxxxxxxxx001111xxxx11000x100000
5512                                                                          sqincb.  */
5513                                                                       return 1787;
5514                                                                     }
5515                                                                   else
5516                                                                     {
5517                                                                       /* 33222222222211111111110000000000
5518                                                                          10987654321098765432109876543210
5519                                                                          xxxxxxxxxx001111xxxx11010x100000
5520                                                                          sqincw.  */
5521                                                                       return 1799;
5522                                                                     }
5523                                                                 }
5524                                                               else
5525                                                                 {
5526                                                                   if (((word >> 23) & 0x1) == 0)
5527                                                                     {
5528                                                                       /* 33222222222211111111110000000000
5529                                                                          10987654321098765432109876543210
5530                                                                          xxxxxxxxxx001111xxxx11100x100000
5531                                                                          sqinch.  */
5532                                                                       return 1793;
5533                                                                     }
5534                                                                   else
5535                                                                     {
5536                                                                       /* 33222222222211111111110000000000
5537                                                                          10987654321098765432109876543210
5538                                                                          xxxxxxxxxx001111xxxx11110x100000
5539                                                                          sqincd.  */
5540                                                                       return 1790;
5541                                                                     }
5542                                                                 }
5543                                                             }
5544                                                         }
5545                                                     }
5546                                                   else
5547                                                     {
5548                                                       if (((word >> 20) & 0x1) == 0)
5549                                                         {
5550                                                           if (((word >> 22) & 0x1) == 0)
5551                                                             {
5552                                                               if (((word >> 23) & 0x1) == 0)
5553                                                                 {
5554                                                                   /* 33222222222211111111110000000000
5555                                                                      10987654321098765432109876543210
5556                                                                      xxxxxxxxxx01x111xxxx01000x100000
5557                                                                      sqdecb.  */
5558                                                                   return 1774;
5559                                                                 }
5560                                                               else
5561                                                                 {
5562                                                                   /* 33222222222211111111110000000000
5563                                                                      10987654321098765432109876543210
5564                                                                      xxxxxxxxxx01x111xxxx01010x100000
5565                                                                      sqdecw.  */
5566                                                                   return 1786;
5567                                                                 }
5568                                                             }
5569                                                           else
5570                                                             {
5571                                                               if (((word >> 23) & 0x1) == 0)
5572                                                                 {
5573                                                                   /* 33222222222211111111110000000000
5574                                                                      10987654321098765432109876543210
5575                                                                      xxxxxxxxxx01x111xxxx01100x100000
5576                                                                      sqdech.  */
5577                                                                   return 1780;
5578                                                                 }
5579                                                               else
5580                                                                 {
5581                                                                   /* 33222222222211111111110000000000
5582                                                                      10987654321098765432109876543210
5583                                                                      xxxxxxxxxx01x111xxxx01110x100000
5584                                                                      sqdecd.  */
5585                                                                   return 1777;
5586                                                                 }
5587                                                             }
5588                                                         }
5589                                                       else
5590                                                         {
5591                                                           if (((word >> 22) & 0x1) == 0)
5592                                                             {
5593                                                               if (((word >> 23) & 0x1) == 0)
5594                                                                 {
5595                                                                   /* 33222222222211111111110000000000
5596                                                                      10987654321098765432109876543210
5597                                                                      xxxxxxxxxx01x111xxxx11000x100000
5598                                                                      sqdecb.  */
5599                                                                   return 1773;
5600                                                                 }
5601                                                               else
5602                                                                 {
5603                                                                   /* 33222222222211111111110000000000
5604                                                                      10987654321098765432109876543210
5605                                                                      xxxxxxxxxx01x111xxxx11010x100000
5606                                                                      sqdecw.  */
5607                                                                   return 1785;
5608                                                                 }
5609                                                             }
5610                                                           else
5611                                                             {
5612                                                               if (((word >> 23) & 0x1) == 0)
5613                                                                 {
5614                                                                   /* 33222222222211111111110000000000
5615                                                                      10987654321098765432109876543210
5616                                                                      xxxxxxxxxx01x111xxxx11100x100000
5617                                                                      sqdech.  */
5618                                                                   return 1779;
5619                                                                 }
5620                                                               else
5621                                                                 {
5622                                                                   /* 33222222222211111111110000000000
5623                                                                      10987654321098765432109876543210
5624                                                                      xxxxxxxxxx01x111xxxx11110x100000
5625                                                                      sqdecd.  */
5626                                                                   return 1776;
5627                                                                 }
5628                                                             }
5629                                                         }
5630                                                     }
5631                                                 }
5632                                               else
5633                                                 {
5634                                                   if (((word >> 11) & 0x1) == 0)
5635                                                     {
5636                                                       if (((word >> 12) & 0x1) == 0)
5637                                                         {
5638                                                           if (((word >> 22) & 0x1) == 0)
5639                                                             {
5640                                                               if (((word >> 23) & 0x1) == 0)
5641                                                                 {
5642                                                                   /* 33222222222211111111110000000000
5643                                                                      10987654321098765432109876543210
5644                                                                      xxxxxxxxxx100111xxxxx1000x100000
5645                                                                      decb.  */
5646                                                                   return 1312;
5647                                                                 }
5648                                                               else
5649                                                                 {
5650                                                                   /* 33222222222211111111110000000000
5651                                                                      10987654321098765432109876543210
5652                                                                      xxxxxxxxxx100111xxxxx1010x100000
5653                                                                      decw.  */
5654                                                                   return 1320;
5655                                                                 }
5656                                                             }
5657                                                           else
5658                                                             {
5659                                                               if (((word >> 23) & 0x1) == 0)
5660                                                                 {
5661                                                                   /* 33222222222211111111110000000000
5662                                                                      10987654321098765432109876543210
5663                                                                      xxxxxxxxxx100111xxxxx1100x100000
5664                                                                      dech.  */
5665                                                                   return 1316;
5666                                                                 }
5667                                                               else
5668                                                                 {
5669                                                                   /* 33222222222211111111110000000000
5670                                                                      10987654321098765432109876543210
5671                                                                      xxxxxxxxxx100111xxxxx1110x100000
5672                                                                      decd.  */
5673                                                                   return 1314;
5674                                                                 }
5675                                                             }
5676                                                         }
5677                                                       else
5678                                                         {
5679                                                           if (((word >> 20) & 0x1) == 0)
5680                                                             {
5681                                                               if (((word >> 22) & 0x1) == 0)
5682                                                                 {
5683                                                                   if (((word >> 23) & 0x1) == 0)
5684                                                                     {
5685                                                                       /* 33222222222211111111110000000000
5686                                                                          10987654321098765432109876543210
5687                                                                          xxxxxxxxxx101111xxxx01000x100000
5688                                                                          uqincb.  */
5689                                                                       return 1935;
5690                                                                     }
5691                                                                   else
5692                                                                     {
5693                                                                       /* 33222222222211111111110000000000
5694                                                                          10987654321098765432109876543210
5695                                                                          xxxxxxxxxx101111xxxx01010x100000
5696                                                                          uqincw.  */
5697                                                                       return 1947;
5698                                                                     }
5699                                                                 }
5700                                                               else
5701                                                                 {
5702                                                                   if (((word >> 23) & 0x1) == 0)
5703                                                                     {
5704                                                                       /* 33222222222211111111110000000000
5705                                                                          10987654321098765432109876543210
5706                                                                          xxxxxxxxxx101111xxxx01100x100000
5707                                                                          uqinch.  */
5708                                                                       return 1941;
5709                                                                     }
5710                                                                   else
5711                                                                     {
5712                                                                       /* 33222222222211111111110000000000
5713                                                                          10987654321098765432109876543210
5714                                                                          xxxxxxxxxx101111xxxx01110x100000
5715                                                                          uqincd.  */
5716                                                                       return 1938;
5717                                                                     }
5718                                                                 }
5719                                                             }
5720                                                           else
5721                                                             {
5722                                                               if (((word >> 22) & 0x1) == 0)
5723                                                                 {
5724                                                                   if (((word >> 23) & 0x1) == 0)
5725                                                                     {
5726                                                                       /* 33222222222211111111110000000000
5727                                                                          10987654321098765432109876543210
5728                                                                          xxxxxxxxxx101111xxxx11000x100000
5729                                                                          uqincb.  */
5730                                                                       return 1936;
5731                                                                     }
5732                                                                   else
5733                                                                     {
5734                                                                       /* 33222222222211111111110000000000
5735                                                                          10987654321098765432109876543210
5736                                                                          xxxxxxxxxx101111xxxx11010x100000
5737                                                                          uqincw.  */
5738                                                                       return 1948;
5739                                                                     }
5740                                                                 }
5741                                                               else
5742                                                                 {
5743                                                                   if (((word >> 23) & 0x1) == 0)
5744                                                                     {
5745                                                                       /* 33222222222211111111110000000000
5746                                                                          10987654321098765432109876543210
5747                                                                          xxxxxxxxxx101111xxxx11100x100000
5748                                                                          uqinch.  */
5749                                                                       return 1942;
5750                                                                     }
5751                                                                   else
5752                                                                     {
5753                                                                       /* 33222222222211111111110000000000
5754                                                                          10987654321098765432109876543210
5755                                                                          xxxxxxxxxx101111xxxx11110x100000
5756                                                                          uqincd.  */
5757                                                                       return 1939;
5758                                                                     }
5759                                                                 }
5760                                                             }
5761                                                         }
5762                                                     }
5763                                                   else
5764                                                     {
5765                                                       if (((word >> 20) & 0x1) == 0)
5766                                                         {
5767                                                           if (((word >> 22) & 0x1) == 0)
5768                                                             {
5769                                                               if (((word >> 23) & 0x1) == 0)
5770                                                                 {
5771                                                                   /* 33222222222211111111110000000000
5772                                                                      10987654321098765432109876543210
5773                                                                      xxxxxxxxxx11x111xxxx01000x100000
5774                                                                      uqdecb.  */
5775                                                                   return 1921;
5776                                                                 }
5777                                                               else
5778                                                                 {
5779                                                                   /* 33222222222211111111110000000000
5780                                                                      10987654321098765432109876543210
5781                                                                      xxxxxxxxxx11x111xxxx01010x100000
5782                                                                      uqdecw.  */
5783                                                                   return 1933;
5784                                                                 }
5785                                                             }
5786                                                           else
5787                                                             {
5788                                                               if (((word >> 23) & 0x1) == 0)
5789                                                                 {
5790                                                                   /* 33222222222211111111110000000000
5791                                                                      10987654321098765432109876543210
5792                                                                      xxxxxxxxxx11x111xxxx01100x100000
5793                                                                      uqdech.  */
5794                                                                   return 1927;
5795                                                                 }
5796                                                               else
5797                                                                 {
5798                                                                   /* 33222222222211111111110000000000
5799                                                                      10987654321098765432109876543210
5800                                                                      xxxxxxxxxx11x111xxxx01110x100000
5801                                                                      uqdecd.  */
5802                                                                   return 1924;
5803                                                                 }
5804                                                             }
5805                                                         }
5806                                                       else
5807                                                         {
5808                                                           if (((word >> 22) & 0x1) == 0)
5809                                                             {
5810                                                               if (((word >> 23) & 0x1) == 0)
5811                                                                 {
5812                                                                   /* 33222222222211111111110000000000
5813                                                                      10987654321098765432109876543210
5814                                                                      xxxxxxxxxx11x111xxxx11000x100000
5815                                                                      uqdecb.  */
5816                                                                   return 1922;
5817                                                                 }
5818                                                               else
5819                                                                 {
5820                                                                   /* 33222222222211111111110000000000
5821                                                                      10987654321098765432109876543210
5822                                                                      xxxxxxxxxx11x111xxxx11010x100000
5823                                                                      uqdecw.  */
5824                                                                   return 1934;
5825                                                                 }
5826                                                             }
5827                                                           else
5828                                                             {
5829                                                               if (((word >> 23) & 0x1) == 0)
5830                                                                 {
5831                                                                   /* 33222222222211111111110000000000
5832                                                                      10987654321098765432109876543210
5833                                                                      xxxxxxxxxx11x111xxxx11100x100000
5834                                                                      uqdech.  */
5835                                                                   return 1928;
5836                                                                 }
5837                                                               else
5838                                                                 {
5839                                                                   /* 33222222222211111111110000000000
5840                                                                      10987654321098765432109876543210
5841                                                                      xxxxxxxxxx11x111xxxx11110x100000
5842                                                                      uqdecd.  */
5843                                                                   return 1925;
5844                                                                 }
5845                                                             }
5846                                                         }
5847                                                     }
5848                                                 }
5849                                             }
5850                                         }
5851                                       else
5852                                         {
5853                                           if (((word >> 22) & 0x1) == 0)
5854                                             {
5855                                               if (((word >> 21) & 0x1) == 0)
5856                                                 {
5857                                                   if (((word >> 23) & 0x1) == 0)
5858                                                     {
5859                                                       /* 33222222222211111111110000000000
5860                                                          10987654321098765432109876543210
5861                                                          xxxxxxxxxxxxx111xxxxx0000x100001
5862                                                          prfb.  */
5863                                                       return 1707;
5864                                                     }
5865                                                   else
5866                                                     {
5867                                                       /* 33222222222211111111110000000000
5868                                                          10987654321098765432109876543210
5869                                                          xxxxxxxxxxxxx111xxxxx0010x100001
5870                                                          prfh.  */
5871                                                       return 1721;
5872                                                     }
5873                                                 }
5874                                               else
5875                                                 {
5876                                                   if (((word >> 23) & 0x1) == 0)
5877                                                     {
5878                                                       /* 33222222222211111111110000000000
5879                                                          10987654321098765432109876543210
5880                                                          xxxxxxxxxxxxx111xxxxx1000x100001
5881                                                          ldff1b.  */
5882                                                       return 1587;
5883                                                     }
5884                                                   else
5885                                                     {
5886                                                       /* 33222222222211111111110000000000
5887                                                          10987654321098765432109876543210
5888                                                          xxxxxxxxxxxxx111xxxxx1010x100001
5889                                                          ldff1h.  */
5890                                                       return 1604;
5891                                                     }
5892                                                 }
5893                                             }
5894                                           else
5895                                             {
5896                                               if (((word >> 23) & 0x1) == 0)
5897                                                 {
5898                                                   /* 33222222222211111111110000000000
5899                                                      10987654321098765432109876543210
5900                                                      xxxxxxxxxxxxx111xxxxxx100x100001
5901                                                      ld1rb.  */
5902                                                   return 1493;
5903                                                 }
5904                                               else
5905                                                 {
5906                                                   /* 33222222222211111111110000000000
5907                                                      10987654321098765432109876543210
5908                                                      xxxxxxxxxxxxx111xxxxxx110x100001
5909                                                      ld1rh.  */
5910                                                   return 1497;
5911                                                 }
5912                                             }
5913                                         }
5914                                     }
5915                                   else
5916                                     {
5917                                       if (((word >> 21) & 0x1) == 0)
5918                                         {
5919                                           if (((word >> 22) & 0x1) == 0)
5920                                             {
5921                                               if (((word >> 23) & 0x1) == 0)
5922                                                 {
5923                                                   /* 33222222222211111111110000000000
5924                                                      10987654321098765432109876543210
5925                                                      xxxxxxxxxxxxx111xxxxx0000x10001x
5926                                                      prfb.  */
5927                                                   return 1709;
5928                                                 }
5929                                               else
5930                                                 {
5931                                                   /* 33222222222211111111110000000000
5932                                                      10987654321098765432109876543210
5933                                                      xxxxxxxxxxxxx111xxxxx0010x10001x
5934                                                      prfh.  */
5935                                                   return 1723;
5936                                                 }
5937                                             }
5938                                           else
5939                                             {
5940                                               if (((word >> 23) & 0x1) == 0)
5941                                                 {
5942                                                   /* 33222222222211111111110000000000
5943                                                      10987654321098765432109876543210
5944                                                      xxxxxxxxxxxxx111xxxxx0100x10001x
5945                                                      ldff1b.  */
5946                                                   return 1586;
5947                                                 }
5948                                               else
5949                                                 {
5950                                                   /* 33222222222211111111110000000000
5951                                                      10987654321098765432109876543210
5952                                                      xxxxxxxxxxxxx111xxxxx0110x10001x
5953                                                      ldff1h.  */
5954                                                   return 1602;
5955                                                 }
5956                                             }
5957                                         }
5958                                       else
5959                                         {
5960                                           if (((word >> 22) & 0x1) == 0)
5961                                             {
5962                                               if (((word >> 23) & 0x1) == 0)
5963                                                 {
5964                                                   /* 33222222222211111111110000000000
5965                                                      10987654321098765432109876543210
5966                                                      xxxxxxxxxxxxx111xxxxx1000x10001x
5967                                                      ldff1b.  */
5968                                                   return 1588;
5969                                                 }
5970                                               else
5971                                                 {
5972                                                   /* 33222222222211111111110000000000
5973                                                      10987654321098765432109876543210
5974                                                      xxxxxxxxxxxxx111xxxxx1010x10001x
5975                                                      ldff1h.  */
5976                                                   return 1605;
5977                                                 }
5978                                             }
5979                                           else
5980                                             {
5981                                               if (((word >> 23) & 0x1) == 0)
5982                                                 {
5983                                                   /* 33222222222211111111110000000000
5984                                                      10987654321098765432109876543210
5985                                                      xxxxxxxxxxxxx111xxxxx1100x10001x
5986                                                      prfd.  */
5987                                                   return 1713;
5988                                                 }
5989                                               else
5990                                                 {
5991                                                   /* 33222222222211111111110000000000
5992                                                      10987654321098765432109876543210
5993                                                      xxxxxxxxxxxxx111xxxxx1110x10001x
5994                                                      ldff1h.  */
5995                                                   return 1603;
5996                                                 }
5997                                             }
5998                                         }
5999                                     }
6000                                 }
6001                             }
6002                         }
6003                     }
6004                   else
6005                     {
6006                       if (((word >> 21) & 0x1) == 0)
6007                         {
6008                           if (((word >> 15) & 0x1) == 0)
6009                             {
6010                               if (((word >> 30) & 0x1) == 0)
6011                                 {
6012                                   if (((word >> 13) & 0x1) == 0)
6013                                     {
6014                                       if (((word >> 14) & 0x1) == 0)
6015                                         {
6016                                           if (((word >> 31) & 0x1) == 0)
6017                                             {
6018                                               if (((word >> 4) & 0x1) == 0)
6019                                                 {
6020                                                   /* 33222222222211111111110000000000
6021                                                      10987654321098765432109876543210
6022                                                      xxxx0xxxxxxxx000xxxxx0xx0x100100
6023                                                      cmphs.  */
6024                                                   return 1285;
6025                                                 }
6026                                               else
6027                                                 {
6028                                                   /* 33222222222211111111110000000000
6029                                                      10987654321098765432109876543210
6030                                                      xxxx1xxxxxxxx000xxxxx0xx0x100100
6031                                                      cmphi.  */
6032                                                   return 1282;
6033                                                 }
6034                                             }
6035                                           else
6036                                             {
6037                                               if (((word >> 23) & 0x1) == 0)
6038                                                 {
6039                                                   /* 33222222222211111111110000000000
6040                                                      10987654321098765432109876543210
6041                                                      xxxxxxxxxxxxx000xxxxx0x00x100101
6042                                                      ld1rqb.  */
6043                                                   return 1499;
6044                                                 }
6045                                               else
6046                                                 {
6047                                                   /* 33222222222211111111110000000000
6048                                                      10987654321098765432109876543210
6049                                                      xxxxxxxxxxxxx000xxxxx0x10x100101
6050                                                      ld1rqh.  */
6051                                                   return 1503;
6052                                                 }
6053                                             }
6054                                         }
6055                                       else
6056                                         {
6057                                           if (((word >> 31) & 0x1) == 0)
6058                                             {
6059                                               if (((word >> 4) & 0x1) == 0)
6060                                                 {
6061                                                   /* 33222222222211111111110000000000
6062                                                      10987654321098765432109876543210
6063                                                      xxxx0xxxxxxxx010xxxxx0xx0x100100
6064                                                      cmpge.  */
6065                                                   return 1276;
6066                                                 }
6067                                               else
6068                                                 {
6069                                                   /* 33222222222211111111110000000000
6070                                                      10987654321098765432109876543210
6071                                                      xxxx1xxxxxxxx010xxxxx0xx0x100100
6072                                                      cmpgt.  */
6073                                                   return 1279;
6074                                                 }
6075                                             }
6076                                           else
6077                                             {
6078                                               if (((word >> 22) & 0x1) == 0)
6079                                                 {
6080                                                   if (((word >> 23) & 0x1) == 0)
6081                                                     {
6082                                                       /* 33222222222211111111110000000000
6083                                                          10987654321098765432109876543210
6084                                                          xxxxxxxxxxxxx010xxxxx0000x100101
6085                                                          ld1b.  */
6086                                                       return 1457;
6087                                                     }
6088                                                   else
6089                                                     {
6090                                                       /* 33222222222211111111110000000000
6091                                                          10987654321098765432109876543210
6092                                                          xxxxxxxxxxxxx010xxxxx0010x100101
6093                                                          ld1sw.  */
6094                                                       return 1537;
6095                                                     }
6096                                                 }
6097                                               else
6098                                                 {
6099                                                   if (((word >> 23) & 0x1) == 0)
6100                                                     {
6101                                                       /* 33222222222211111111110000000000
6102                                                          10987654321098765432109876543210
6103                                                          xxxxxxxxxxxxx010xxxxx0100x100101
6104                                                          ld1b.  */
6105                                                       return 1459;
6106                                                     }
6107                                                   else
6108                                                     {
6109                                                       /* 33222222222211111111110000000000
6110                                                          10987654321098765432109876543210
6111                                                          xxxxxxxxxxxxx010xxxxx0110x100101
6112                                                          ld1h.  */
6113                                                       return 1479;
6114                                                     }
6115                                                 }
6116                                             }
6117                                         }
6118                                     }
6119                                   else
6120                                     {
6121                                       if (((word >> 14) & 0x1) == 0)
6122                                         {
6123                                           if (((word >> 31) & 0x1) == 0)
6124                                             {
6125                                               if (((word >> 4) & 0x1) == 0)
6126                                                 {
6127                                                   /* 33222222222211111111110000000000
6128                                                      10987654321098765432109876543210
6129                                                      xxxx0xxxxxxxx100xxxxx0xx0x100100
6130                                                      cmpeq.  */
6131                                                   return 1273;
6132                                                 }
6133                                               else
6134                                                 {
6135                                                   /* 33222222222211111111110000000000
6136                                                      10987654321098765432109876543210
6137                                                      xxxx1xxxxxxxx100xxxxx0xx0x100100
6138                                                      cmpne.  */
6139                                                   return 1296;
6140                                                 }
6141                                             }
6142                                           else
6143                                             {
6144                                               if (((word >> 23) & 0x1) == 0)
6145                                                 {
6146                                                   /* 33222222222211111111110000000000
6147                                                      10987654321098765432109876543210
6148                                                      xxxxxxxxxxxxx100xxxxx0x00x100101
6149                                                      ld1rqb.  */
6150                                                   return 1498;
6151                                                 }
6152                                               else
6153                                                 {
6154                                                   /* 33222222222211111111110000000000
6155                                                      10987654321098765432109876543210
6156                                                      xxxxxxxxxxxxx100xxxxx0x10x100101
6157                                                      ld1rqh.  */
6158                                                   return 1502;
6159                                                 }
6160                                             }
6161                                         }
6162                                       else
6163                                         {
6164                                           if (((word >> 31) & 0x1) == 0)
6165                                             {
6166                                               if (((word >> 4) & 0x1) == 0)
6167                                                 {
6168                                                   /* 33222222222211111111110000000000
6169                                                      10987654321098765432109876543210
6170                                                      xxxx0xxxxxxxx110xxxxx0xx0x100100
6171                                                      cmplt.  */
6172                                                   return 1294;
6173                                                 }
6174                                               else
6175                                                 {
6176                                                   /* 33222222222211111111110000000000
6177                                                      10987654321098765432109876543210
6178                                                      xxxx1xxxxxxxx110xxxxx0xx0x100100
6179                                                      cmple.  */
6180                                                   return 1288;
6181                                                 }
6182                                             }
6183                                           else
6184                                             {
6185                                               if (((word >> 22) & 0x1) == 0)
6186                                                 {
6187                                                   if (((word >> 23) & 0x1) == 0)
6188                                                     {
6189                                                       /* 33222222222211111111110000000000
6190                                                          10987654321098765432109876543210
6191                                                          xxxxxxxxxxxxx110xxxxx0000x100101
6192                                                          ldff1b.  */
6193                                                       return 1581;
6194                                                     }
6195                                                   else
6196                                                     {
6197                                                       /* 33222222222211111111110000000000
6198                                                          10987654321098765432109876543210
6199                                                          xxxxxxxxxxxxx110xxxxx0010x100101
6200                                                          ldff1sw.  */
6201                                                       return 1624;
6202                                                     }
6203                                                 }
6204                                               else
6205                                                 {
6206                                                   if (((word >> 23) & 0x1) == 0)
6207                                                     {
6208                                                       /* 33222222222211111111110000000000
6209                                                          10987654321098765432109876543210
6210                                                          xxxxxxxxxxxxx110xxxxx0100x100101
6211                                                          ldff1b.  */
6212                                                       return 1583;
6213                                                     }
6214                                                   else
6215                                                     {
6216                                                       /* 33222222222211111111110000000000
6217                                                          10987654321098765432109876543210
6218                                                          xxxxxxxxxxxxx110xxxxx0110x100101
6219                                                          ldff1h.  */
6220                                                       return 1598;
6221                                                     }
6222                                                 }
6223                                             }
6224                                         }
6225                                     }
6226                                 }
6227                               else
6228                                 {
6229                                   if (((word >> 31) & 0x1) == 0)
6230                                     {
6231                                       /* 33222222222211111111110000000000
6232                                          10987654321098765432109876543210
6233                                          xxxxxxxxxxxxxxx0xxxxx0xx0x100110
6234                                          fcmla.  */
6235                                       return 1342;
6236                                     }
6237                                   else
6238                                     {
6239                                       if (((word >> 13) & 0x1) == 0)
6240                                         {
6241                                           if (((word >> 22) & 0x1) == 0)
6242                                             {
6243                                               /* 33222222222211111111110000000000
6244                                                  10987654321098765432109876543210
6245                                                  xxxxxxxxxxxxx0x0xxxxx00x0x100111
6246                                                  st1b.  */
6247                                               return 1803;
6248                                             }
6249                                           else
6250                                             {
6251                                               if (((word >> 23) & 0x1) == 0)
6252                                                 {
6253                                                   /* 33222222222211111111110000000000
6254                                                      10987654321098765432109876543210
6255                                                      xxxxxxxxxxxxx0x0xxxxx0100x100111
6256                                                      st1b.  */
6257                                                   return 1807;
6258                                                 }
6259                                               else
6260                                                 {
6261                                                   /* 33222222222211111111110000000000
6262                                                      10987654321098765432109876543210
6263                                                      xxxxxxxxxxxxx0x0xxxxx0110x100111
6264                                                      st1h.  */
6265                                                   return 1828;
6266                                                 }
6267                                             }
6268                                         }
6269                                       else
6270                                         {
6271                                           if (((word >> 22) & 0x1) == 0)
6272                                             {
6273                                               if (((word >> 23) & 0x1) == 0)
6274                                                 {
6275                                                   /* 33222222222211111111110000000000
6276                                                      10987654321098765432109876543210
6277                                                      xxxxxxxxxxxxx1x0xxxxx0000x100111
6278                                                      stnt1b.  */
6279                                                   return 1873;
6280                                                 }
6281                                               else
6282                                                 {
6283                                                   /* 33222222222211111111110000000000
6284                                                      10987654321098765432109876543210
6285                                                      xxxxxxxxxxxxx1x0xxxxx0010x100111
6286                                                      stnt1h.  */
6287                                                   return 1877;
6288                                                 }
6289                                             }
6290                                           else
6291                                             {
6292                                               if (((word >> 23) & 0x1) == 0)
6293                                                 {
6294                                                   /* 33222222222211111111110000000000
6295                                                      10987654321098765432109876543210
6296                                                      xxxxxxxxxxxxx1x0xxxxx0100x100111
6297                                                      st3b.  */
6298                                                   return 1857;
6299                                                 }
6300                                               else
6301                                                 {
6302                                                   /* 33222222222211111111110000000000
6303                                                      10987654321098765432109876543210
6304                                                      xxxxxxxxxxxxx1x0xxxxx0110x100111
6305                                                      st3h.  */
6306                                                   return 1861;
6307                                                 }
6308                                             }
6309                                         }
6310                                     }
6311                                 }
6312                             }
6313                           else
6314                             {
6315                               if (((word >> 13) & 0x1) == 0)
6316                                 {
6317                                   if (((word >> 30) & 0x1) == 0)
6318                                     {
6319                                       if (((word >> 14) & 0x1) == 0)
6320                                         {
6321                                           if (((word >> 4) & 0x1) == 0)
6322                                             {
6323                                               /* 33222222222211111111110000000000
6324                                                  10987654321098765432109876543210
6325                                                  xxxx0xxxxxxxx001xxxxx0xx0x10010x
6326                                                  cmpge.  */
6327                                               return 1277;
6328                                             }
6329                                           else
6330                                             {
6331                                               /* 33222222222211111111110000000000
6332                                                  10987654321098765432109876543210
6333                                                  xxxx1xxxxxxxx001xxxxx0xx0x10010x
6334                                                  cmpgt.  */
6335                                               return 1280;
6336                                             }
6337                                         }
6338                                       else
6339                                         {
6340                                           if (((word >> 31) & 0x1) == 0)
6341                                             {
6342                                               if (((word >> 4) & 0x1) == 0)
6343                                                 {
6344                                                   /* 33222222222211111111110000000000
6345                                                      10987654321098765432109876543210
6346                                                      xxxx0xxxxxxxx011xxxxx0xx0x100100
6347                                                      cmphs.  */
6348                                                   return 1286;
6349                                                 }
6350                                               else
6351                                                 {
6352                                                   /* 33222222222211111111110000000000
6353                                                      10987654321098765432109876543210
6354                                                      xxxx1xxxxxxxx011xxxxx0xx0x100100
6355                                                      cmphi.  */
6356                                                   return 1283;
6357                                                 }
6358                                             }
6359                                           else
6360                                             {
6361                                               if (((word >> 22) & 0x1) == 0)
6362                                                 {
6363                                                   if (((word >> 23) & 0x1) == 0)
6364                                                     {
6365                                                       /* 33222222222211111111110000000000
6366                                                          10987654321098765432109876543210
6367                                                          xxxxxxxxxxxxx011xxxxx0000x100101
6368                                                          ldnt1b.  */
6369                                                       return 1656;
6370                                                     }
6371                                                   else
6372                                                     {
6373                                                       /* 33222222222211111111110000000000
6374                                                          10987654321098765432109876543210
6375                                                          xxxxxxxxxxxxx011xxxxx0010x100101
6376                                                          ldnt1h.  */
6377                                                       return 1660;
6378                                                     }
6379                                                 }
6380                                               else
6381                                                 {
6382                                                   if (((word >> 23) & 0x1) == 0)
6383                                                     {
6384                                                       /* 33222222222211111111110000000000
6385                                                          10987654321098765432109876543210
6386                                                          xxxxxxxxxxxxx011xxxxx0100x100101
6387                                                          ld3b.  */
6388                                                       return 1564;
6389                                                     }
6390                                                   else
6391                                                     {
6392                                                       /* 33222222222211111111110000000000
6393                                                          10987654321098765432109876543210
6394                                                          xxxxxxxxxxxxx011xxxxx0110x100101
6395                                                          ld3h.  */
6396                                                       return 1568;
6397                                                     }
6398                                                 }
6399                                             }
6400                                         }
6401                                     }
6402                                   else
6403                                     {
6404                                       if (((word >> 31) & 0x1) == 0)
6405                                         {
6406                                           /* 33222222222211111111110000000000
6407                                              10987654321098765432109876543210
6408                                              xxxxxxxxxxxxx0x1xxxxx0xx0x100110
6409                                              fcadd.  */
6410                                           return 1341;
6411                                         }
6412                                       else
6413                                         {
6414                                           if (((word >> 22) & 0x1) == 0)
6415                                             {
6416                                               if (((word >> 23) & 0x1) == 0)
6417                                                 {
6418                                                   /* 33222222222211111111110000000000
6419                                                      10987654321098765432109876543210
6420                                                      xxxxxxxxxxxxx0x1xxxxx0000x100111
6421                                                      st1b.  */
6422                                                   return 1804;
6423                                                 }
6424                                               else
6425                                                 {
6426                                                   /* 33222222222211111111110000000000
6427                                                      10987654321098765432109876543210
6428                                                      xxxxxxxxxxxxx0x1xxxxx0010x100111
6429                                                      st1h.  */
6430                                                   return 1823;
6431                                                 }
6432                                             }
6433                                           else
6434                                             {
6435                                               if (((word >> 23) & 0x1) == 0)
6436                                                 {
6437                                                   /* 33222222222211111111110000000000
6438                                                      10987654321098765432109876543210
6439                                                      xxxxxxxxxxxxx0x1xxxxx0100x100111
6440                                                      st1b.  */
6441                                                   return 1808;
6442                                                 }
6443                                               else
6444                                                 {
6445                                                   /* 33222222222211111111110000000000
6446                                                      10987654321098765432109876543210
6447                                                      xxxxxxxxxxxxx0x1xxxxx0110x100111
6448                                                      st1h.  */
6449                                                   return 1829;
6450                                                 }
6451                                             }
6452                                         }
6453                                     }
6454                                 }
6455                               else
6456                                 {
6457                                   if (((word >> 14) & 0x1) == 0)
6458                                     {
6459                                       if (((word >> 30) & 0x1) == 0)
6460                                         {
6461                                           if (((word >> 31) & 0x1) == 0)
6462                                             {
6463                                               if (((word >> 4) & 0x1) == 0)
6464                                                 {
6465                                                   /* 33222222222211111111110000000000
6466                                                      10987654321098765432109876543210
6467                                                      xxxx0xxxxxxxx101xxxxx0xx0x100100
6468                                                      cmpeq.  */
6469                                                   return 1274;
6470                                                 }
6471                                               else
6472                                                 {
6473                                                   /* 33222222222211111111110000000000
6474                                                      10987654321098765432109876543210
6475                                                      xxxx1xxxxxxxx101xxxxx0xx0x100100
6476                                                      cmpne.  */
6477                                                   return 1297;
6478                                                 }
6479                                             }
6480                                           else
6481                                             {
6482                                               if (((word >> 20) & 0x1) == 0)
6483                                                 {
6484                                                   if (((word >> 22) & 0x1) == 0)
6485                                                     {
6486                                                       if (((word >> 23) & 0x1) == 0)
6487                                                         {
6488                                                           /* 33222222222211111111110000000000
6489                                                              10987654321098765432109876543210
6490                                                              xxxxxxxxxxxxx101xxxx00000x100101
6491                                                              ld1b.  */
6492                                                           return 1464;
6493                                                         }
6494                                                       else
6495                                                         {
6496                                                           /* 33222222222211111111110000000000
6497                                                              10987654321098765432109876543210
6498                                                              xxxxxxxxxxxxx101xxxx00010x100101
6499                                                              ld1sw.  */
6500                                                           return 1542;
6501                                                         }
6502                                                     }
6503                                                   else
6504                                                     {
6505                                                       if (((word >> 23) & 0x1) == 0)
6506                                                         {
6507                                                           /* 33222222222211111111110000000000
6508                                                              10987654321098765432109876543210
6509                                                              xxxxxxxxxxxxx101xxxx00100x100101
6510                                                              ld1b.  */
6511                                                           return 1466;
6512                                                         }
6513                                                       else
6514                                                         {
6515                                                           /* 33222222222211111111110000000000
6516                                                              10987654321098765432109876543210
6517                                                              xxxxxxxxxxxxx101xxxx00110x100101
6518                                                              ld1h.  */
6519                                                           return 1487;
6520                                                         }
6521                                                     }
6522                                                 }
6523                                               else
6524                                                 {
6525                                                   if (((word >> 22) & 0x1) == 0)
6526                                                     {
6527                                                       if (((word >> 23) & 0x1) == 0)
6528                                                         {
6529                                                           /* 33222222222211111111110000000000
6530                                                              10987654321098765432109876543210
6531                                                              xxxxxxxxxxxxx101xxxx10000x100101
6532                                                              ldnf1b.  */
6533                                                           return 1640;
6534                                                         }
6535                                                       else
6536                                                         {
6537                                                           /* 33222222222211111111110000000000
6538                                                              10987654321098765432109876543210
6539                                                              xxxxxxxxxxxxx101xxxx10010x100101
6540                                                              ldnf1sw.  */
6541                                                           return 1653;
6542                                                         }
6543                                                     }
6544                                                   else
6545                                                     {
6546                                                       if (((word >> 23) & 0x1) == 0)
6547                                                         {
6548                                                           /* 33222222222211111111110000000000
6549                                                              10987654321098765432109876543210
6550                                                              xxxxxxxxxxxxx101xxxx10100x100101
6551                                                              ldnf1b.  */
6552                                                           return 1642;
6553                                                         }
6554                                                       else
6555                                                         {
6556                                                           /* 33222222222211111111110000000000
6557                                                              10987654321098765432109876543210
6558                                                              xxxxxxxxxxxxx101xxxx10110x100101
6559                                                              ldnf1h.  */
6560                                                           return 1646;
6561                                                         }
6562                                                     }
6563                                                 }
6564                                             }
6565                                         }
6566                                       else
6567                                         {
6568                                           if (((word >> 22) & 0x1) == 0)
6569                                             {
6570                                               if (((word >> 23) & 0x1) == 0)
6571                                                 {
6572                                                   /* 33222222222211111111110000000000
6573                                                      10987654321098765432109876543210
6574                                                      xxxxxxxxxxxxx101xxxxx0000x10011x
6575                                                      st1b.  */
6576                                                   return 1805;
6577                                                 }
6578                                               else
6579                                                 {
6580                                                   /* 33222222222211111111110000000000
6581                                                      10987654321098765432109876543210
6582                                                      xxxxxxxxxxxxx101xxxxx0010x10011x
6583                                                      st1h.  */
6584                                                   return 1824;
6585                                                 }
6586                                             }
6587                                           else
6588                                             {
6589                                               if (((word >> 23) & 0x1) == 0)
6590                                                 {
6591                                                   /* 33222222222211111111110000000000
6592                                                      10987654321098765432109876543210
6593                                                      xxxxxxxxxxxxx101xxxxx0100x10011x
6594                                                      st1b.  */
6595                                                   return 1812;
6596                                                 }
6597                                               else
6598                                                 {
6599                                                   /* 33222222222211111111110000000000
6600                                                      10987654321098765432109876543210
6601                                                      xxxxxxxxxxxxx101xxxxx0110x10011x
6602                                                      st1h.  */
6603                                                   return 1833;
6604                                                 }
6605                                             }
6606                                         }
6607                                     }
6608                                   else
6609                                     {
6610                                       if (((word >> 30) & 0x1) == 0)
6611                                         {
6612                                           if (((word >> 31) & 0x1) == 0)
6613                                             {
6614                                               if (((word >> 4) & 0x1) == 0)
6615                                                 {
6616                                                   /* 33222222222211111111110000000000
6617                                                      10987654321098765432109876543210
6618                                                      xxxx0xxxxxxxx111xxxxx0xx0x100100
6619                                                      cmplo.  */
6620                                                   return 1290;
6621                                                 }
6622                                               else
6623                                                 {
6624                                                   /* 33222222222211111111110000000000
6625                                                      10987654321098765432109876543210
6626                                                      xxxx1xxxxxxxx111xxxxx0xx0x100100
6627                                                      cmpls.  */
6628                                                   return 1292;
6629                                                 }
6630                                             }
6631                                           else
6632                                             {
6633                                               if (((word >> 22) & 0x1) == 0)
6634                                                 {
6635                                                   if (((word >> 23) & 0x1) == 0)
6636                                                     {
6637                                                       /* 33222222222211111111110000000000
6638                                                          10987654321098765432109876543210
6639                                                          xxxxxxxxxxxxx111xxxxx0000x100101
6640                                                          ldnt1b.  */
6641                                                       return 1657;
6642                                                     }
6643                                                   else
6644                                                     {
6645                                                       /* 33222222222211111111110000000000
6646                                                          10987654321098765432109876543210
6647                                                          xxxxxxxxxxxxx111xxxxx0010x100101
6648                                                          ldnt1h.  */
6649                                                       return 1661;
6650                                                     }
6651                                                 }
6652                                               else
6653                                                 {
6654                                                   if (((word >> 23) & 0x1) == 0)
6655                                                     {
6656                                                       /* 33222222222211111111110000000000
6657                                                          10987654321098765432109876543210
6658                                                          xxxxxxxxxxxxx111xxxxx0100x100101
6659                                                          ld3b.  */
6660                                                       return 1565;
6661                                                     }
6662                                                   else
6663                                                     {
6664                                                       /* 33222222222211111111110000000000
6665                                                          10987654321098765432109876543210
6666                                                          xxxxxxxxxxxxx111xxxxx0110x100101
6667                                                          ld3h.  */
6668                                                       return 1569;
6669                                                     }
6670                                                 }
6671                                             }
6672                                         }
6673                                       else
6674                                         {
6675                                           if (((word >> 20) & 0x1) == 0)
6676                                             {
6677                                               if (((word >> 22) & 0x1) == 0)
6678                                                 {
6679                                                   /* 33222222222211111111110000000000
6680                                                      10987654321098765432109876543210
6681                                                      xxxxxxxxxxxxx111xxxx000x0x10011x
6682                                                      st1b.  */
6683                                                   return 1810;
6684                                                 }
6685                                               else
6686                                                 {
6687                                                   if (((word >> 23) & 0x1) == 0)
6688                                                     {
6689                                                       /* 33222222222211111111110000000000
6690                                                          10987654321098765432109876543210
6691                                                          xxxxxxxxxxxxx111xxxx00100x10011x
6692                                                          st1b.  */
6693                                                       return 1813;
6694                                                     }
6695                                                   else
6696                                                     {
6697                                                       /* 33222222222211111111110000000000
6698                                                          10987654321098765432109876543210
6699                                                          xxxxxxxxxxxxx111xxxx00110x10011x
6700                                                          st1h.  */
6701                                                       return 1834;
6702                                                     }
6703                                                 }
6704                                             }
6705                                           else
6706                                             {
6707                                               if (((word >> 22) & 0x1) == 0)
6708                                                 {
6709                                                   if (((word >> 23) & 0x1) == 0)
6710                                                     {
6711                                                       /* 33222222222211111111110000000000
6712                                                          10987654321098765432109876543210
6713                                                          xxxxxxxxxxxxx111xxxx10000x10011x
6714                                                          stnt1b.  */
6715                                                       return 1874;
6716                                                     }
6717                                                   else
6718                                                     {
6719                                                       /* 33222222222211111111110000000000
6720                                                          10987654321098765432109876543210
6721                                                          xxxxxxxxxxxxx111xxxx10010x10011x
6722                                                          stnt1h.  */
6723                                                       return 1878;
6724                                                     }
6725                                                 }
6726                                               else
6727                                                 {
6728                                                   if (((word >> 23) & 0x1) == 0)
6729                                                     {
6730                                                       /* 33222222222211111111110000000000
6731                                                          10987654321098765432109876543210
6732                                                          xxxxxxxxxxxxx111xxxx10100x10011x
6733                                                          st3b.  */
6734                                                       return 1858;
6735                                                     }
6736                                                   else
6737                                                     {
6738                                                       /* 33222222222211111111110000000000
6739                                                          10987654321098765432109876543210
6740                                                          xxxxxxxxxxxxx111xxxx10110x10011x
6741                                                          st3h.  */
6742                                                       return 1862;
6743                                                     }
6744                                                 }
6745                                             }
6746                                         }
6747                                     }
6748                                 }
6749                             }
6750                         }
6751                       else
6752                         {
6753                           if (((word >> 13) & 0x1) == 0)
6754                             {
6755                               if (((word >> 30) & 0x1) == 0)
6756                                 {
6757                                   if (((word >> 31) & 0x1) == 0)
6758                                     {
6759                                       if (((word >> 4) & 0x1) == 0)
6760                                         {
6761                                           /* 33222222222211111111110000000000
6762                                              10987654321098765432109876543210
6763                                              xxxx0xxxxxxxx0xxxxxxx1xx0x100100
6764                                              cmphs.  */
6765                                           return 1287;
6766                                         }
6767                                       else
6768                                         {
6769                                           /* 33222222222211111111110000000000
6770                                              10987654321098765432109876543210
6771                                              xxxx1xxxxxxxx0xxxxxxx1xx0x100100
6772                                              cmphi.  */
6773                                           return 1284;
6774                                         }
6775                                     }
6776                                   else
6777                                     {
6778                                       if (((word >> 15) & 0x1) == 0)
6779                                         {
6780                                           if (((word >> 22) & 0x1) == 0)
6781                                             {
6782                                               if (((word >> 23) & 0x1) == 0)
6783                                                 {
6784                                                   /* 33222222222211111111110000000000
6785                                                      10987654321098765432109876543210
6786                                                      xxxxxxxxxxxxx0x0xxxxx1000x100101
6787                                                      ld1b.  */
6788                                                   return 1458;
6789                                                 }
6790                                               else
6791                                                 {
6792                                                   /* 33222222222211111111110000000000
6793                                                      10987654321098765432109876543210
6794                                                      xxxxxxxxxxxxx0x0xxxxx1010x100101
6795                                                      ld1h.  */
6796                                                   return 1478;
6797                                                 }
6798                                             }
6799                                           else
6800                                             {
6801                                               if (((word >> 23) & 0x1) == 0)
6802                                                 {
6803                                                   /* 33222222222211111111110000000000
6804                                                      10987654321098765432109876543210
6805                                                      xxxxxxxxxxxxx0x0xxxxx1100x100101
6806                                                      ld1b.  */
6807                                                   return 1460;
6808                                                 }
6809                                               else
6810                                                 {
6811                                                   /* 33222222222211111111110000000000
6812                                                      10987654321098765432109876543210
6813                                                      xxxxxxxxxxxxx0x0xxxxx1110x100101
6814                                                      ld1h.  */
6815                                                   return 1480;
6816                                                 }
6817                                             }
6818                                         }
6819                                       else
6820                                         {
6821                                           if (((word >> 22) & 0x1) == 0)
6822                                             {
6823                                               if (((word >> 23) & 0x1) == 0)
6824                                                 {
6825                                                   /* 33222222222211111111110000000000
6826                                                      10987654321098765432109876543210
6827                                                      xxxxxxxxxxxxx0x1xxxxx1000x100101
6828                                                      ld2b.  */
6829                                                   return 1556;
6830                                                 }
6831                                               else
6832                                                 {
6833                                                   /* 33222222222211111111110000000000
6834                                                      10987654321098765432109876543210
6835                                                      xxxxxxxxxxxxx0x1xxxxx1010x100101
6836                                                      ld2h.  */
6837                                                   return 1560;
6838                                                 }
6839                                             }
6840                                           else
6841                                             {
6842                                               if (((word >> 23) & 0x1) == 0)
6843                                                 {
6844                                                   /* 33222222222211111111110000000000
6845                                                      10987654321098765432109876543210
6846                                                      xxxxxxxxxxxxx0x1xxxxx1100x100101
6847                                                      ld4b.  */
6848                                                   return 1572;
6849                                                 }
6850                                               else
6851                                                 {
6852                                                   /* 33222222222211111111110000000000
6853                                                      10987654321098765432109876543210
6854                                                      xxxxxxxxxxxxx0x1xxxxx1110x100101
6855                                                      ld4h.  */
6856                                                   return 1576;
6857                                                 }
6858                                             }
6859                                         }
6860                                     }
6861                                 }
6862                               else
6863                                 {
6864                                   if (((word >> 15) & 0x1) == 0)
6865                                     {
6866                                       if (((word >> 14) & 0x1) == 0)
6867                                         {
6868                                           if (((word >> 12) & 0x1) == 0)
6869                                             {
6870                                               if (((word >> 10) & 0x1) == 0)
6871                                                 {
6872                                                   if (((word >> 23) & 0x1) == 0)
6873                                                     {
6874                                                       /* 33222222222211111111110000000000
6875                                                          10987654321098765432109876543210
6876                                                          xxxxxxxxxx0x0000xxxxx1x00x10011x
6877                                                          fmla.  */
6878                                                       return 1395;
6879                                                     }
6880                                                   else
6881                                                     {
6882                                                       if (((word >> 22) & 0x1) == 0)
6883                                                         {
6884                                                           /* 33222222222211111111110000000000
6885                                                              10987654321098765432109876543210
6886                                                              xxxxxxxxxx0x0000xxxxx1010x10011x
6887                                                              fmla.  */
6888                                                           return 1396;
6889                                                         }
6890                                                       else
6891                                                         {
6892                                                           /* 33222222222211111111110000000000
6893                                                              10987654321098765432109876543210
6894                                                              xxxxxxxxxx0x0000xxxxx1110x10011x
6895                                                              fmla.  */
6896                                                           return 1397;
6897                                                         }
6898                                                     }
6899                                                 }
6900                                               else
6901                                                 {
6902                                                   if (((word >> 23) & 0x1) == 0)
6903                                                     {
6904                                                       /* 33222222222211111111110000000000
6905                                                          10987654321098765432109876543210
6906                                                          xxxxxxxxxx1x0000xxxxx1x00x10011x
6907                                                          fmls.  */
6908                                                       return 1399;
6909                                                     }
6910                                                   else
6911                                                     {
6912                                                       if (((word >> 22) & 0x1) == 0)
6913                                                         {
6914                                                           /* 33222222222211111111110000000000
6915                                                              10987654321098765432109876543210
6916                                                              xxxxxxxxxx1x0000xxxxx1010x10011x
6917                                                              fmls.  */
6918                                                           return 1400;
6919                                                         }
6920                                                       else
6921                                                         {
6922                                                           /* 33222222222211111111110000000000
6923                                                              10987654321098765432109876543210
6924                                                              xxxxxxxxxx1x0000xxxxx1110x10011x
6925                                                              fmls.  */
6926                                                           return 1401;
6927                                                         }
6928                                                     }
6929                                                 }
6930                                             }
6931                                           else
6932                                             {
6933                                               if (((word >> 22) & 0x1) == 0)
6934                                                 {
6935                                                   /* 33222222222211111111110000000000
6936                                                      10987654321098765432109876543210
6937                                                      xxxxxxxxxxxx1000xxxxx10x0x10011x
6938                                                      fcmla.  */
6939                                                   return 1343;
6940                                                 }
6941                                               else
6942                                                 {
6943                                                   /* 33222222222211111111110000000000
6944                                                      10987654321098765432109876543210
6945                                                      xxxxxxxxxxxx1000xxxxx11x0x10011x
6946                                                      fcmla.  */
6947                                                   return 1344;
6948                                                 }
6949                                             }
6950                                         }
6951                                       else
6952                                         {
6953                                           if (((word >> 22) & 0x1) == 0)
6954                                             {
6955                                               if (((word >> 23) & 0x1) == 0)
6956                                                 {
6957                                                   /* 33222222222211111111110000000000
6958                                                      10987654321098765432109876543210
6959                                                      xxxxxxxxxxxxx010xxxxx1000x10011x
6960                                                      st1b.  */
6961                                                   return 1806;
6962                                                 }
6963                                               else
6964                                                 {
6965                                                   /* 33222222222211111111110000000000
6966                                                      10987654321098765432109876543210
6967                                                      xxxxxxxxxxxxx010xxxxx1010x10011x
6968                                                      st1h.  */
6969                                                   return 1825;
6970                                                 }
6971                                             }
6972                                           else
6973                                             {
6974                                               if (((word >> 23) & 0x1) == 0)
6975                                                 {
6976                                                   /* 33222222222211111111110000000000
6977                                                      10987654321098765432109876543210
6978                                                      xxxxxxxxxxxxx010xxxxx1100x10011x
6979                                                      st1b.  */
6980                                                   return 1809;
6981                                                 }
6982                                               else
6983                                                 {
6984                                                   /* 33222222222211111111110000000000
6985                                                      10987654321098765432109876543210
6986                                                      xxxxxxxxxxxxx010xxxxx1110x10011x
6987                                                      st1h.  */
6988                                                   return 1830;
6989                                                 }
6990                                             }
6991                                         }
6992                                     }
6993                                   else
6994                                     {
6995                                       if (((word >> 22) & 0x1) == 0)
6996                                         {
6997                                           /* 33222222222211111111110000000000
6998                                              10987654321098765432109876543210
6999                                              xxxxxxxxxxxxx0x1xxxxx10x0x10011x
7000                                              st1h.  */
7001                                           return 1826;
7002                                         }
7003                                       else
7004                                         {
7005                                           /* 33222222222211111111110000000000
7006                                              10987654321098765432109876543210
7007                                              xxxxxxxxxxxxx0x1xxxxx11x0x10011x
7008                                              st1h.  */
7009                                           return 1831;
7010                                         }
7011                                     }
7012                                 }
7013                             }
7014                           else
7015                             {
7016                               if (((word >> 30) & 0x1) == 0)
7017                                 {
7018                                   if (((word >> 31) & 0x1) == 0)
7019                                     {
7020                                       if (((word >> 4) & 0x1) == 0)
7021                                         {
7022                                           /* 33222222222211111111110000000000
7023                                              10987654321098765432109876543210
7024                                              xxxx0xxxxxxxx1xxxxxxx1xx0x100100
7025                                              cmplo.  */
7026                                           return 1291;
7027                                         }
7028                                       else
7029                                         {
7030                                           /* 33222222222211111111110000000000
7031                                              10987654321098765432109876543210
7032                                              xxxx1xxxxxxxx1xxxxxxx1xx0x100100
7033                                              cmpls.  */
7034                                           return 1293;
7035                                         }
7036                                     }
7037                                   else
7038                                     {
7039                                       if (((word >> 14) & 0x1) == 0)
7040                                         {
7041                                           if (((word >> 20) & 0x1) == 0)
7042                                             {
7043                                               if (((word >> 22) & 0x1) == 0)
7044                                                 {
7045                                                   if (((word >> 23) & 0x1) == 0)
7046                                                     {
7047                                                       /* 33222222222211111111110000000000
7048                                                          10987654321098765432109876543210
7049                                                          xxxxxxxxxxxxx10xxxxx01000x100101
7050                                                          ld1b.  */
7051                                                       return 1465;
7052                                                     }
7053                                                   else
7054                                                     {
7055                                                       /* 33222222222211111111110000000000
7056                                                          10987654321098765432109876543210
7057                                                          xxxxxxxxxxxxx10xxxxx01010x100101
7058                                                          ld1h.  */
7059                                                       return 1486;
7060                                                     }
7061                                                 }
7062                                               else
7063                                                 {
7064                                                   if (((word >> 23) & 0x1) == 0)
7065                                                     {
7066                                                       /* 33222222222211111111110000000000
7067                                                          10987654321098765432109876543210
7068                                                          xxxxxxxxxxxxx10xxxxx01100x100101
7069                                                          ld1b.  */
7070                                                       return 1467;
7071                                                     }
7072                                                   else
7073                                                     {
7074                                                       /* 33222222222211111111110000000000
7075                                                          10987654321098765432109876543210
7076                                                          xxxxxxxxxxxxx10xxxxx01110x100101
7077                                                          ld1h.  */
7078                                                       return 1488;
7079                                                     }
7080                                                 }
7081                                             }
7082                                           else
7083                                             {
7084                                               if (((word >> 22) & 0x1) == 0)
7085                                                 {
7086                                                   if (((word >> 23) & 0x1) == 0)
7087                                                     {
7088                                                       /* 33222222222211111111110000000000
7089                                                          10987654321098765432109876543210
7090                                                          xxxxxxxxxxxxx10xxxxx11000x100101
7091                                                          ldnf1b.  */
7092                                                       return 1641;
7093                                                     }
7094                                                   else
7095                                                     {
7096                                                       /* 33222222222211111111110000000000
7097                                                          10987654321098765432109876543210
7098                                                          xxxxxxxxxxxxx10xxxxx11010x100101
7099                                                          ldnf1h.  */
7100                                                       return 1645;
7101                                                     }
7102                                                 }
7103                                               else
7104                                                 {
7105                                                   if (((word >> 23) & 0x1) == 0)
7106                                                     {
7107                                                       /* 33222222222211111111110000000000
7108                                                          10987654321098765432109876543210
7109                                                          xxxxxxxxxxxxx10xxxxx11100x100101
7110                                                          ldnf1b.  */
7111                                                       return 1643;
7112                                                     }
7113                                                   else
7114                                                     {
7115                                                       /* 33222222222211111111110000000000
7116                                                          10987654321098765432109876543210
7117                                                          xxxxxxxxxxxxx10xxxxx11110x100101
7118                                                          ldnf1h.  */
7119                                                       return 1647;
7120                                                     }
7121                                                 }
7122                                             }
7123                                         }
7124                                       else
7125                                         {
7126                                           if (((word >> 15) & 0x1) == 0)
7127                                             {
7128                                               if (((word >> 22) & 0x1) == 0)
7129                                                 {
7130                                                   if (((word >> 23) & 0x1) == 0)
7131                                                     {
7132                                                       /* 33222222222211111111110000000000
7133                                                          10987654321098765432109876543210
7134                                                          xxxxxxxxxxxxx110xxxxx1000x100101
7135                                                          ldff1b.  */
7136                                                       return 1582;
7137                                                     }
7138                                                   else
7139                                                     {
7140                                                       /* 33222222222211111111110000000000
7141                                                          10987654321098765432109876543210
7142                                                          xxxxxxxxxxxxx110xxxxx1010x100101
7143                                                          ldff1h.  */
7144                                                       return 1597;
7145                                                     }
7146                                                 }
7147                                               else
7148                                                 {
7149                                                   if (((word >> 23) & 0x1) == 0)
7150                                                     {
7151                                                       /* 33222222222211111111110000000000
7152                                                          10987654321098765432109876543210
7153                                                          xxxxxxxxxxxxx110xxxxx1100x100101
7154                                                          ldff1b.  */
7155                                                       return 1584;
7156                                                     }
7157                                                   else
7158                                                     {
7159                                                       /* 33222222222211111111110000000000
7160                                                          10987654321098765432109876543210
7161                                                          xxxxxxxxxxxxx110xxxxx1110x100101
7162                                                          ldff1h.  */
7163                                                       return 1599;
7164                                                     }
7165                                                 }
7166                                             }
7167                                           else
7168                                             {
7169                                               if (((word >> 22) & 0x1) == 0)
7170                                                 {
7171                                                   if (((word >> 23) & 0x1) == 0)
7172                                                     {
7173                                                       /* 33222222222211111111110000000000
7174                                                          10987654321098765432109876543210
7175                                                          xxxxxxxxxxxxx111xxxxx1000x100101
7176                                                          ld2b.  */
7177                                                       return 1557;
7178                                                     }
7179                                                   else
7180                                                     {
7181                                                       /* 33222222222211111111110000000000
7182                                                          10987654321098765432109876543210
7183                                                          xxxxxxxxxxxxx111xxxxx1010x100101
7184                                                          ld2h.  */
7185                                                       return 1561;
7186                                                     }
7187                                                 }
7188                                               else
7189                                                 {
7190                                                   if (((word >> 23) & 0x1) == 0)
7191                                                     {
7192                                                       /* 33222222222211111111110000000000
7193                                                          10987654321098765432109876543210
7194                                                          xxxxxxxxxxxxx111xxxxx1100x100101
7195                                                          ld4b.  */
7196                                                       return 1573;
7197                                                     }
7198                                                   else
7199                                                     {
7200                                                       /* 33222222222211111111110000000000
7201                                                          10987654321098765432109876543210
7202                                                          xxxxxxxxxxxxx111xxxxx1110x100101
7203                                                          ld4h.  */
7204                                                       return 1577;
7205                                                     }
7206                                                 }
7207                                             }
7208                                         }
7209                                     }
7210                                 }
7211                               else
7212                                 {
7213                                   if (((word >> 14) & 0x1) == 0)
7214                                     {
7215                                       if (((word >> 15) & 0x1) == 0)
7216                                         {
7217                                           if (((word >> 23) & 0x1) == 0)
7218                                             {
7219                                               /* 33222222222211111111110000000000
7220                                                  10987654321098765432109876543210
7221                                                  xxxxxxxxxxxxx100xxxxx1x00x10011x
7222                                                  fmul.  */
7223                                               return 1406;
7224                                             }
7225                                           else
7226                                             {
7227                                               if (((word >> 22) & 0x1) == 0)
7228                                                 {
7229                                                   /* 33222222222211111111110000000000
7230                                                      10987654321098765432109876543210
7231                                                      xxxxxxxxxxxxx100xxxxx1010x10011x
7232                                                      fmul.  */
7233                                                   return 1407;
7234                                                 }
7235                                               else
7236                                                 {
7237                                                   /* 33222222222211111111110000000000
7238                                                      10987654321098765432109876543210
7239                                                      xxxxxxxxxxxxx100xxxxx1110x10011x
7240                                                      fmul.  */
7241                                                   return 1408;
7242                                                 }
7243                                             }
7244                                         }
7245                                       else
7246                                         {
7247                                           if (((word >> 22) & 0x1) == 0)
7248                                             {
7249                                               /* 33222222222211111111110000000000
7250                                                  10987654321098765432109876543210
7251                                                  xxxxxxxxxxxxx101xxxxx10x0x10011x
7252                                                  st1h.  */
7253                                               return 1827;
7254                                             }
7255                                           else
7256                                             {
7257                                               if (((word >> 23) & 0x1) == 0)
7258                                                 {
7259                                                   /* 33222222222211111111110000000000
7260                                                      10987654321098765432109876543210
7261                                                      xxxxxxxxxxxxx101xxxxx1100x10011x
7262                                                      st1b.  */
7263                                                   return 1814;
7264                                                 }
7265                                               else
7266                                                 {
7267                                                   /* 33222222222211111111110000000000
7268                                                      10987654321098765432109876543210
7269                                                      xxxxxxxxxxxxx101xxxxx1110x10011x
7270                                                      st1h.  */
7271                                                   return 1835;
7272                                                 }
7273                                             }
7274                                         }
7275                                     }
7276                                   else
7277                                     {
7278                                       if (((word >> 15) & 0x1) == 0)
7279                                         {
7280                                           if (((word >> 22) & 0x1) == 0)
7281                                             {
7282                                               if (((word >> 23) & 0x1) == 0)
7283                                                 {
7284                                                   /* 33222222222211111111110000000000
7285                                                      10987654321098765432109876543210
7286                                                      xxxxxxxxxxxxx110xxxxx1000x10011x
7287                                                      st2b.  */
7288                                                   return 1849;
7289                                                 }
7290                                               else
7291                                                 {
7292                                                   /* 33222222222211111111110000000000
7293                                                      10987654321098765432109876543210
7294                                                      xxxxxxxxxxxxx110xxxxx1010x10011x
7295                                                      st2h.  */
7296                                                   return 1853;
7297                                                 }
7298                                             }
7299                                           else
7300                                             {
7301                                               if (((word >> 23) & 0x1) == 0)
7302                                                 {
7303                                                   /* 33222222222211111111110000000000
7304                                                      10987654321098765432109876543210
7305                                                      xxxxxxxxxxxxx110xxxxx1100x10011x
7306                                                      st4b.  */
7307                                                   return 1865;
7308                                                 }
7309                                               else
7310                                                 {
7311                                                   /* 33222222222211111111110000000000
7312                                                      10987654321098765432109876543210
7313                                                      xxxxxxxxxxxxx110xxxxx1110x10011x
7314                                                      st4h.  */
7315                                                   return 1869;
7316                                                 }
7317                                             }
7318                                         }
7319                                       else
7320                                         {
7321                                           if (((word >> 20) & 0x1) == 0)
7322                                             {
7323                                               if (((word >> 22) & 0x1) == 0)
7324                                                 {
7325                                                   if (((word >> 23) & 0x1) == 0)
7326                                                     {
7327                                                       /* 33222222222211111111110000000000
7328                                                          10987654321098765432109876543210
7329                                                          xxxxxxxxxxxxx111xxxx01000x10011x
7330                                                          st1b.  */
7331                                                       return 1811;
7332                                                     }
7333                                                   else
7334                                                     {
7335                                                       /* 33222222222211111111110000000000
7336                                                          10987654321098765432109876543210
7337                                                          xxxxxxxxxxxxx111xxxx01010x10011x
7338                                                          st1h.  */
7339                                                       return 1832;
7340                                                     }
7341                                                 }
7342                                               else
7343                                                 {
7344                                                   if (((word >> 23) & 0x1) == 0)
7345                                                     {
7346                                                       /* 33222222222211111111110000000000
7347                                                          10987654321098765432109876543210
7348                                                          xxxxxxxxxxxxx111xxxx01100x10011x
7349                                                          st1b.  */
7350                                                       return 1815;
7351                                                     }
7352                                                   else
7353                                                     {
7354                                                       /* 33222222222211111111110000000000
7355                                                          10987654321098765432109876543210
7356                                                          xxxxxxxxxxxxx111xxxx01110x10011x
7357                                                          st1h.  */
7358                                                       return 1836;
7359                                                     }
7360                                                 }
7361                                             }
7362                                           else
7363                                             {
7364                                               if (((word >> 22) & 0x1) == 0)
7365                                                 {
7366                                                   if (((word >> 23) & 0x1) == 0)
7367                                                     {
7368                                                       /* 33222222222211111111110000000000
7369                                                          10987654321098765432109876543210
7370                                                          xxxxxxxxxxxxx111xxxx11000x10011x
7371                                                          st2b.  */
7372                                                       return 1850;
7373                                                     }
7374                                                   else
7375                                                     {
7376                                                       /* 33222222222211111111110000000000
7377                                                          10987654321098765432109876543210
7378                                                          xxxxxxxxxxxxx111xxxx11010x10011x
7379                                                          st2h.  */
7380                                                       return 1854;
7381                                                     }
7382                                                 }
7383                                               else
7384                                                 {
7385                                                   if (((word >> 23) & 0x1) == 0)
7386                                                     {
7387                                                       /* 33222222222211111111110000000000
7388                                                          10987654321098765432109876543210
7389                                                          xxxxxxxxxxxxx111xxxx11100x10011x
7390                                                          st4b.  */
7391                                                       return 1866;
7392                                                     }
7393                                                   else
7394                                                     {
7395                                                       /* 33222222222211111111110000000000
7396                                                          10987654321098765432109876543210
7397                                                          xxxxxxxxxxxxx111xxxx11110x10011x
7398                                                          st4h.  */
7399                                                       return 1870;
7400                                                     }
7401                                                 }
7402                                             }
7403                                         }
7404                                     }
7405                                 }
7406                             }
7407                         }
7408                     }
7409                 }
7410               else
7411                 {
7412                   if (((word >> 29) & 0x1) == 0)
7413                     {
7414                       if (((word >> 30) & 0x1) == 0)
7415                         {
7416                           if (((word >> 31) & 0x1) == 0)
7417                             {
7418                               if (((word >> 21) & 0x1) == 0)
7419                                 {
7420                                   if (((word >> 20) & 0x1) == 0)
7421                                     {
7422                                       if (((word >> 22) & 0x1) == 0)
7423                                         {
7424                                           if (((word >> 23) & 0x1) == 0)
7425                                             {
7426                                               /* 33222222222211111111110000000000
7427                                                  10987654321098765432109876543210
7428                                                  xxxxxxxxxxxxxxxxxxxx00001x100000
7429                                                  orr.  */
7430                                               return 1695;
7431                                             }
7432                                           else
7433                                             {
7434                                               /* 33222222222211111111110000000000
7435                                                  10987654321098765432109876543210
7436                                                  xxxxxxxxxxxxxxxxxxxx00011x100000
7437                                                  and.  */
7438                                               return 1239;
7439                                             }
7440                                         }
7441                                       else
7442                                         {
7443                                           if (((word >> 23) & 0x1) == 0)
7444                                             {
7445                                               /* 33222222222211111111110000000000
7446                                                  10987654321098765432109876543210
7447                                                  xxxxxxxxxxxxxxxxxxxx00101x100000
7448                                                  eor.  */
7449                                               return 1326;
7450                                             }
7451                                           else
7452                                             {
7453                                               /* 33222222222211111111110000000000
7454                                                  10987654321098765432109876543210
7455                                                  xxxxxxxxxxxxxxxxxxxx00111x100000
7456                                                  dupm.  */
7457                                               return 1324;
7458                                             }
7459                                         }
7460                                     }
7461                                   else
7462                                     {
7463                                       if (((word >> 15) & 0x1) == 0)
7464                                         {
7465                                           /* 33222222222211111111110000000000
7466                                              10987654321098765432109876543210
7467                                              xxxxxxxxxxxxxxx0xxxx10xx1x100000
7468                                              cpy.  */
7469                                           return 1309;
7470                                         }
7471                                       else
7472                                         {
7473                                           /* 33222222222211111111110000000000
7474                                              10987654321098765432109876543210
7475                                              xxxxxxxxxxxxxxx1xxxx10xx1x100000
7476                                              fcpy.  */
7477                                           return 1356;
7478                                         }
7479                                     }
7480                                 }
7481                               else
7482                                 {
7483                                   if (((word >> 14) & 0x1) == 0)
7484                                     {
7485                                       if (((word >> 13) & 0x1) == 0)
7486                                         {
7487                                           if (((word >> 15) & 0x1) == 0)
7488                                             {
7489                                               /* 33222222222211111111110000000000
7490                                                  10987654321098765432109876543210
7491                                                  xxxxxxxxxxxxx000xxxxx1xx1x100000
7492                                                  ext.  */
7493                                               return 1331;
7494                                             }
7495                                           else
7496                                             {
7497                                               if (((word >> 16) & 0x1) == 0)
7498                                                 {
7499                                                   if (((word >> 17) & 0x1) == 0)
7500                                                     {
7501                                                       if (((word >> 18) & 0x1) == 0)
7502                                                         {
7503                                                           if (((word >> 19) & 0x1) == 0)
7504                                                             {
7505                                                               /* 33222222222211111111110000000000
7506                                                                  10987654321098765432109876543210
7507                                                                  xxxxxxxxxxxxx0010000x1xx1x100000
7508                                                                  cpy.  */
7509                                                               return 1307;
7510                                                             }
7511                                                           else
7512                                                             {
7513                                                               /* 33222222222211111111110000000000
7514                                                                  10987654321098765432109876543210
7515                                                                  xxxxxxxxxxxxx0010001x1xx1x100000
7516                                                                  clasta.  */
7517                                                               return 1265;
7518                                                             }
7519                                                         }
7520                                                       else
7521                                                         {
7522                                                           if (((word >> 19) & 0x1) == 0)
7523                                                             {
7524                                                               /* 33222222222211111111110000000000
7525                                                                  10987654321098765432109876543210
7526                                                                  xxxxxxxxxxxxx0010010x1xx1x100000
7527                                                                  revb.  */
7528                                                               return 1743;
7529                                                             }
7530                                                           else
7531                                                             {
7532                                                               /* 33222222222211111111110000000000
7533                                                                  10987654321098765432109876543210
7534                                                                  xxxxxxxxxxxxx0010011x1xx1x100000
7535                                                                  splice.  */
7536                                                               return 1770;
7537                                                             }
7538                                                         }
7539                                                     }
7540                                                   else
7541                                                     {
7542                                                       if (((word >> 18) & 0x1) == 0)
7543                                                         {
7544                                                           if (((word >> 19) & 0x1) == 0)
7545                                                             {
7546                                                               /* 33222222222211111111110000000000
7547                                                                  10987654321098765432109876543210
7548                                                                  xxxxxxxxxxxxx0010100x1xx1x100000
7549                                                                  lasta.  */
7550                                                               return 1453;
7551                                                             }
7552                                                           else
7553                                                             {
7554                                                               /* 33222222222211111111110000000000
7555                                                                  10987654321098765432109876543210
7556                                                                  xxxxxxxxxxxxx0010101x1xx1x100000
7557                                                                  clasta.  */
7558                                                               return 1266;
7559                                                             }
7560                                                         }
7561                                                       else
7562                                                         {
7563                                                           /* 33222222222211111111110000000000
7564                                                              10987654321098765432109876543210
7565                                                              xxxxxxxxxxxxx001011xx1xx1x100000
7566                                                              revw.  */
7567                                                           return 1745;
7568                                                         }
7569                                                     }
7570                                                 }
7571                                               else
7572                                                 {
7573                                                   if (((word >> 17) & 0x1) == 0)
7574                                                     {
7575                                                       if (((word >> 18) & 0x1) == 0)
7576                                                         {
7577                                                           if (((word >> 19) & 0x1) == 0)
7578                                                             {
7579                                                               /* 33222222222211111111110000000000
7580                                                                  10987654321098765432109876543210
7581                                                                  xxxxxxxxxxxxx0011000x1xx1x100000
7582                                                                  compact.  */
7583                                                               return 1306;
7584                                                             }
7585                                                           else
7586                                                             {
7587                                                               /* 33222222222211111111110000000000
7588                                                                  10987654321098765432109876543210
7589                                                                  xxxxxxxxxxxxx0011001x1xx1x100000
7590                                                                  clastb.  */
7591                                                               return 1268;
7592                                                             }
7593                                                         }
7594                                                       else
7595                                                         {
7596                                                           /* 33222222222211111111110000000000
7597                                                              10987654321098765432109876543210
7598                                                              xxxxxxxxxxxxx001101xx1xx1x100000
7599                                                              revh.  */
7600                                                           return 1744;
7601                                                         }
7602                                                     }
7603                                                   else
7604                                                     {
7605                                                       if (((word >> 18) & 0x1) == 0)
7606                                                         {
7607                                                           if (((word >> 19) & 0x1) == 0)
7608                                                             {
7609                                                               /* 33222222222211111111110000000000
7610                                                                  10987654321098765432109876543210
7611                                                                  xxxxxxxxxxxxx0011100x1xx1x100000
7612                                                                  lastb.  */
7613                                                               return 1455;
7614                                                             }
7615                                                           else
7616                                                             {
7617                                                               /* 33222222222211111111110000000000
7618                                                                  10987654321098765432109876543210
7619                                                                  xxxxxxxxxxxxx0011101x1xx1x100000
7620                                                                  clastb.  */
7621                                                               return 1269;
7622                                                             }
7623                                                         }
7624                                                       else
7625                                                         {
7626                                                           /* 33222222222211111111110000000000
7627                                                              10987654321098765432109876543210
7628                                                              xxxxxxxxxxxxx001111xx1xx1x100000
7629                                                              rbit.  */
7630                                                           return 1736;
7631                                                         }
7632                                                     }
7633                                                 }
7634                                             }
7635                                         }
7636                                       else
7637                                         {
7638                                           if (((word >> 15) & 0x1) == 0)
7639                                             {
7640                                               if (((word >> 11) & 0x1) == 0)
7641                                                 {
7642                                                   if (((word >> 12) & 0x1) == 0)
7643                                                     {
7644                                                       /* 33222222222211111111110000000000
7645                                                          10987654321098765432109876543210
7646                                                          xxxxxxxxxxx00100xxxxx1xx1x100000
7647                                                          dup.  */
7648                                                       return 1322;
7649                                                     }
7650                                                   else
7651                                                     {
7652                                                       /* 33222222222211111111110000000000
7653                                                          10987654321098765432109876543210
7654                                                          xxxxxxxxxxx01100xxxxx1xx1x100000
7655                                                          tbl.  */
7656                                                       return 1893;
7657                                                     }
7658                                                 }
7659                                               else
7660                                                 {
7661                                                   if (((word >> 16) & 0x1) == 0)
7662                                                     {
7663                                                       if (((word >> 17) & 0x1) == 0)
7664                                                         {
7665                                                           if (((word >> 18) & 0x1) == 0)
7666                                                             {
7667                                                               if (((word >> 19) & 0x1) == 0)
7668                                                                 {
7669                                                                   if (((word >> 20) & 0x1) == 0)
7670                                                                     {
7671                                                                       /* 33222222222211111111110000000000
7672                                                                          10987654321098765432109876543210
7673                                                                          xxxxxxxxxxx1x100000001xx1x100000
7674                                                                          dup.  */
7675                                                                       return 1321;
7676                                                                     }
7677                                                                   else
7678                                                                     {
7679                                                                       /* 33222222222211111111110000000000
7680                                                                          10987654321098765432109876543210
7681                                                                          xxxxxxxxxxx1x100000011xx1x100000
7682                                                                          sunpklo.  */
7683                                                                       return 1889;
7684                                                                     }
7685                                                                 }
7686                                                               else
7687                                                                 {
7688                                                                   /* 33222222222211111111110000000000
7689                                                                      10987654321098765432109876543210
7690                                                                      xxxxxxxxxxx1x1000001x1xx1x100000
7691                                                                      rev.  */
7692                                                                   return 1742;
7693                                                                 }
7694                                                             }
7695                                                           else
7696                                                             {
7697                                                               if (((word >> 20) & 0x1) == 0)
7698                                                                 {
7699                                                                   /* 33222222222211111111110000000000
7700                                                                      10987654321098765432109876543210
7701                                                                      xxxxxxxxxxx1x100001x01xx1x100000
7702                                                                      insr.  */
7703                                                                   return 1450;
7704                                                                 }
7705                                                               else
7706                                                                 {
7707                                                                   /* 33222222222211111111110000000000
7708                                                                      10987654321098765432109876543210
7709                                                                      xxxxxxxxxxx1x100001x11xx1x100000
7710                                                                      insr.  */
7711                                                                   return 1451;
7712                                                                 }
7713                                                             }
7714                                                         }
7715                                                       else
7716                                                         {
7717                                                           /* 33222222222211111111110000000000
7718                                                              10987654321098765432109876543210
7719                                                              xxxxxxxxxxx1x10001xxx1xx1x100000
7720                                                              uunpklo.  */
7721                                                           return 1952;
7722                                                         }
7723                                                     }
7724                                                   else
7725                                                     {
7726                                                       if (((word >> 17) & 0x1) == 0)
7727                                                         {
7728                                                           /* 33222222222211111111110000000000
7729                                                              10987654321098765432109876543210
7730                                                              xxxxxxxxxxx1x10010xxx1xx1x100000
7731                                                              sunpkhi.  */
7732                                                           return 1888;
7733                                                         }
7734                                                       else
7735                                                         {
7736                                                           /* 33222222222211111111110000000000
7737                                                              10987654321098765432109876543210
7738                                                              xxxxxxxxxxx1x10011xxx1xx1x100000
7739                                                              uunpkhi.  */
7740                                                           return 1951;
7741                                                         }
7742                                                     }
7743                                                 }
7744                                             }
7745                                           else
7746                                             {
7747                                               if (((word >> 16) & 0x1) == 0)
7748                                                 {
7749                                                   if (((word >> 19) & 0x1) == 0)
7750                                                     {
7751                                                       if (((word >> 20) & 0x1) == 0)
7752                                                         {
7753                                                           /* 33222222222211111111110000000000
7754                                                              10987654321098765432109876543210
7755                                                              xxxxxxxxxxxxx1010xx001xx1x100000
7756                                                              lasta.  */
7757                                                           return 1452;
7758                                                         }
7759                                                       else
7760                                                         {
7761                                                           /* 33222222222211111111110000000000
7762                                                              10987654321098765432109876543210
7763                                                              xxxxxxxxxxxxx1010xx011xx1x100000
7764                                                              clasta.  */
7765                                                           return 1267;
7766                                                         }
7767                                                     }
7768                                                   else
7769                                                     {
7770                                                       /* 33222222222211111111110000000000
7771                                                          10987654321098765432109876543210
7772                                                          xxxxxxxxxxxxx1010xx1x1xx1x100000
7773                                                          cpy.  */
7774                                                       return 1308;
7775                                                     }
7776                                                 }
7777                                               else
7778                                                 {
7779                                                   if (((word >> 20) & 0x1) == 0)
7780                                                     {
7781                                                       /* 33222222222211111111110000000000
7782                                                          10987654321098765432109876543210
7783                                                          xxxxxxxxxxxxx1011xxx01xx1x100000
7784                                                          lastb.  */
7785                                                       return 1454;
7786                                                     }
7787                                                   else
7788                                                     {
7789                                                       /* 33222222222211111111110000000000
7790                                                          10987654321098765432109876543210
7791                                                          xxxxxxxxxxxxx1011xxx11xx1x100000
7792                                                          clastb.  */
7793                                                       return 1270;
7794                                                     }
7795                                                 }
7796                                             }
7797                                         }
7798                                     }
7799                                   else
7800                                     {
7801                                       if (((word >> 15) & 0x1) == 0)
7802                                         {
7803                                           if (((word >> 10) & 0x1) == 0)
7804                                             {
7805                                               if (((word >> 11) & 0x1) == 0)
7806                                                 {
7807                                                   if (((word >> 12) & 0x1) == 0)
7808                                                     {
7809                                                       if (((word >> 13) & 0x1) == 0)
7810                                                         {
7811                                                           if (((word >> 20) & 0x1) == 0)
7812                                                             {
7813                                                               /* 33222222222211111111110000000000
7814                                                                  10987654321098765432109876543210
7815                                                                  xxxxxxxxxx000010xxxx01xx1x100000
7816                                                                  zip1.  */
7817                                                               return 1969;
7818                                                             }
7819                                                           else
7820                                                             {
7821                                                               if (((word >> 16) & 0x1) == 0)
7822                                                                 {
7823                                                                   if (((word >> 18) & 0x1) == 0)
7824                                                                     {
7825                                                                       /* 33222222222211111111110000000000
7826                                                                          10987654321098765432109876543210
7827                                                                          xxxxxxxxxx0000100x0x11xx1x100000
7828                                                                          punpklo.  */
7829                                                                       return 1735;
7830                                                                     }
7831                                                                   else
7832                                                                     {
7833                                                                       /* 33222222222211111111110000000000
7834                                                                          10987654321098765432109876543210
7835                                                                          xxxxxxxxxx0000100x1x11xx1x100000
7836                                                                          rev.  */
7837                                                                       return 1741;
7838                                                                     }
7839                                                                 }
7840                                                               else
7841                                                                 {
7842                                                                   /* 33222222222211111111110000000000
7843                                                                      10987654321098765432109876543210
7844                                                                      xxxxxxxxxx0000101xxx11xx1x100000
7845                                                                      punpkhi.  */
7846                                                                   return 1734;
7847                                                                 }
7848                                                             }
7849                                                         }
7850                                                       else
7851                                                         {
7852                                                           /* 33222222222211111111110000000000
7853                                                              10987654321098765432109876543210
7854                                                              xxxxxxxxxx000110xxxxx1xx1x100000
7855                                                              zip1.  */
7856                                                           return 1970;
7857                                                         }
7858                                                     }
7859                                                   else
7860                                                     {
7861                                                       if (((word >> 13) & 0x1) == 0)
7862                                                         {
7863                                                           /* 33222222222211111111110000000000
7864                                                              10987654321098765432109876543210
7865                                                              xxxxxxxxxx001010xxxxx1xx1x100000
7866                                                              trn1.  */
7867                                                           return 1894;
7868                                                         }
7869                                                       else
7870                                                         {
7871                                                           /* 33222222222211111111110000000000
7872                                                              10987654321098765432109876543210
7873                                                              xxxxxxxxxx001110xxxxx1xx1x100000
7874                                                              trn1.  */
7875                                                           return 1895;
7876                                                         }
7877                                                     }
7878                                                 }
7879                                               else
7880                                                 {
7881                                                   if (((word >> 13) & 0x1) == 0)
7882                                                     {
7883                                                       /* 33222222222211111111110000000000
7884                                                          10987654321098765432109876543210
7885                                                          xxxxxxxxxx01x010xxxxx1xx1x100000
7886                                                          uzp1.  */
7887                                                       return 1956;
7888                                                     }
7889                                                   else
7890                                                     {
7891                                                       /* 33222222222211111111110000000000
7892                                                          10987654321098765432109876543210
7893                                                          xxxxxxxxxx01x110xxxxx1xx1x100000
7894                                                          uzp1.  */
7895                                                       return 1957;
7896                                                     }
7897                                                 }
7898                                             }
7899                                           else
7900                                             {
7901                                               if (((word >> 11) & 0x1) == 0)
7902                                                 {
7903                                                   if (((word >> 12) & 0x1) == 0)
7904                                                     {
7905                                                       if (((word >> 13) & 0x1) == 0)
7906                                                         {
7907                                                           /* 33222222222211111111110000000000
7908                                                              10987654321098765432109876543210
7909                                                              xxxxxxxxxx100010xxxxx1xx1x100000
7910                                                              zip2.  */
7911                                                           return 1971;
7912                                                         }
7913                                                       else
7914                                                         {
7915                                                           /* 33222222222211111111110000000000
7916                                                              10987654321098765432109876543210
7917                                                              xxxxxxxxxx100110xxxxx1xx1x100000
7918                                                              zip2.  */
7919                                                           return 1972;
7920                                                         }
7921                                                     }
7922                                                   else
7923                                                     {
7924                                                       if (((word >> 13) & 0x1) == 0)
7925                                                         {
7926                                                           /* 33222222222211111111110000000000
7927                                                              10987654321098765432109876543210
7928                                                              xxxxxxxxxx101010xxxxx1xx1x100000
7929                                                              trn2.  */
7930                                                           return 1896;
7931                                                         }
7932                                                       else
7933                                                         {
7934                                                           /* 33222222222211111111110000000000
7935                                                              10987654321098765432109876543210
7936                                                              xxxxxxxxxx101110xxxxx1xx1x100000
7937                                                              trn2.  */
7938                                                           return 1897;
7939                                                         }
7940                                                     }
7941                                                 }
7942                                               else
7943                                                 {
7944                                                   if (((word >> 13) & 0x1) == 0)
7945                                                     {
7946                                                       /* 33222222222211111111110000000000
7947                                                          10987654321098765432109876543210
7948                                                          xxxxxxxxxx11x010xxxxx1xx1x100000
7949                                                          uzp2.  */
7950                                                       return 1958;
7951                                                     }
7952                                                   else
7953                                                     {
7954                                                       /* 33222222222211111111110000000000
7955                                                          10987654321098765432109876543210
7956                                                          xxxxxxxxxx11x110xxxxx1xx1x100000
7957                                                          uzp2.  */
7958                                                       return 1959;
7959                                                     }
7960                                                 }
7961                                             }
7962                                         }
7963                                       else
7964                                         {
7965                                           /* 33222222222211111111110000000000
7966                                              10987654321098765432109876543210
7967                                              xxxxxxxxxxxxxx11xxxxx1xx1x100000
7968                                              sel.  */
7969                                           return 1760;
7970                                         }
7971                                     }
7972                                 }
7973                             }
7974                           else
7975                             {
7976                               if (((word >> 13) & 0x1) == 0)
7977                                 {
7978                                   if (((word >> 14) & 0x1) == 0)
7979                                     {
7980                                       if (((word >> 15) & 0x1) == 0)
7981                                         {
7982                                           if (((word >> 22) & 0x1) == 0)
7983                                             {
7984                                               /* 33222222222211111111110000000000
7985                                                  10987654321098765432109876543210
7986                                                  xxxxxxxxxxxxx000xxxxxx0x1x100001
7987                                                  ldr.  */
7988                                               return 1664;
7989                                             }
7990                                           else
7991                                             {
7992                                               /* 33222222222211111111110000000000
7993                                                  10987654321098765432109876543210
7994                                                  xxxxxxxxxxxxx000xxxxxx1x1x100001
7995                                                  prfb.  */
7996                                               return 1708;
7997                                             }
7998                                         }
7999                                       else
8000                                         {
8001                                           if (((word >> 23) & 0x1) == 0)
8002                                             {
8003                                               /* 33222222222211111111110000000000
8004                                                  10987654321098765432109876543210
8005                                                  xxxxxxxxxxxxx001xxxxxxx01x100001
8006                                                  ld1rsh.  */
8007                                               return 1509;
8008                                             }
8009                                           else
8010                                             {
8011                                               /* 33222222222211111111110000000000
8012                                                  10987654321098765432109876543210
8013                                                  xxxxxxxxxxxxx001xxxxxxx11x100001
8014                                                  ld1rsb.  */
8015                                               return 1506;
8016                                             }
8017                                         }
8018                                     }
8019                                   else
8020                                     {
8021                                       if (((word >> 15) & 0x1) == 0)
8022                                         {
8023                                           if (((word >> 23) & 0x1) == 0)
8024                                             {
8025                                               if (((word >> 21) & 0x1) == 0)
8026                                                 {
8027                                                   /* 33222222222211111111110000000000
8028                                                      10987654321098765432109876543210
8029                                                      xxxxxxxxxxxxx010xxxxx0x01x100001
8030                                                      ld1w.  */
8031                                                   return 1544;
8032                                                 }
8033                                               else
8034                                                 {
8035                                                   /* 33222222222211111111110000000000
8036                                                      10987654321098765432109876543210
8037                                                      xxxxxxxxxxxxx010xxxxx1x01x100001
8038                                                      ld1w.  */
8039                                                   return 1545;
8040                                                 }
8041                                             }
8042                                           else
8043                                             {
8044                                               if (((word >> 22) & 0x1) == 0)
8045                                                 {
8046                                                   /* 33222222222211111111110000000000
8047                                                      10987654321098765432109876543210
8048                                                      xxxxxxxxxxxxx010xxxxxx011x100001
8049                                                      ldr.  */
8050                                                   return 1665;
8051                                                 }
8052                                               else
8053                                                 {
8054                                                   /* 33222222222211111111110000000000
8055                                                      10987654321098765432109876543210
8056                                                      xxxxxxxxxxxxx010xxxxxx111x100001
8057                                                      prfw.  */
8058                                                   return 1729;
8059                                                 }
8060                                             }
8061                                         }
8062                                       else
8063                                         {
8064                                           if (((word >> 22) & 0x1) == 0)
8065                                             {
8066                                               if (((word >> 21) & 0x1) == 0)
8067                                                 {
8068                                                   if (((word >> 23) & 0x1) == 0)
8069                                                     {
8070                                                       /* 33222222222211111111110000000000
8071                                                          10987654321098765432109876543210
8072                                                          xxxxxxxxxxxxx011xxxxx0001x100001
8073                                                          prfw.  */
8074                                                       return 1725;
8075                                                     }
8076                                                   else
8077                                                     {
8078                                                       /* 33222222222211111111110000000000
8079                                                          10987654321098765432109876543210
8080                                                          xxxxxxxxxxxxx011xxxxx0011x100001
8081                                                          prfd.  */
8082                                                       return 1711;
8083                                                     }
8084                                                 }
8085                                               else
8086                                                 {
8087                                                   /* 33222222222211111111110000000000
8088                                                      10987654321098765432109876543210
8089                                                      xxxxxxxxxxxxx011xxxxx10x1x100001
8090                                                      ld1w.  */
8091                                                   return 1552;
8092                                                 }
8093                                             }
8094                                           else
8095                                             {
8096                                               if (((word >> 23) & 0x1) == 0)
8097                                                 {
8098                                                   /* 33222222222211111111110000000000
8099                                                      10987654321098765432109876543210
8100                                                      xxxxxxxxxxxxx011xxxxxx101x100001
8101                                                      ld1rw.  */
8102                                                   return 1512;
8103                                                 }
8104                                               else
8105                                                 {
8106                                                   /* 33222222222211111111110000000000
8107                                                      10987654321098765432109876543210
8108                                                      xxxxxxxxxxxxx011xxxxxx111x100001
8109                                                      ld1rsb.  */
8110                                                   return 1508;
8111                                                 }
8112                                             }
8113                                         }
8114                                     }
8115                                 }
8116                               else
8117                                 {
8118                                   if (((word >> 14) & 0x1) == 0)
8119                                     {
8120                                       if (((word >> 15) & 0x1) == 0)
8121                                         {
8122                                           /* 33222222222211111111110000000000
8123                                              10987654321098765432109876543210
8124                                              xxxxxxxxxxxxx100xxxxxxxx1x100001
8125                                              prfh.  */
8126                                           return 1722;
8127                                         }
8128                                       else
8129                                         {
8130                                           if (((word >> 23) & 0x1) == 0)
8131                                             {
8132                                               /* 33222222222211111111110000000000
8133                                                  10987654321098765432109876543210
8134                                                  xxxxxxxxxxxxx101xxxxxxx01x100001
8135                                                  ld1rsh.  */
8136                                               return 1510;
8137                                             }
8138                                           else
8139                                             {
8140                                               /* 33222222222211111111110000000000
8141                                                  10987654321098765432109876543210
8142                                                  xxxxxxxxxxxxx101xxxxxxx11x100001
8143                                                  ld1rsb.  */
8144                                               return 1507;
8145                                             }
8146                                         }
8147                                     }
8148                                   else
8149                                     {
8150                                       if (((word >> 15) & 0x1) == 0)
8151                                         {
8152                                           if (((word >> 23) & 0x1) == 0)
8153                                             {
8154                                               if (((word >> 21) & 0x1) == 0)
8155                                                 {
8156                                                   /* 33222222222211111111110000000000
8157                                                      10987654321098765432109876543210
8158                                                      xxxxxxxxxxxxx110xxxxx0x01x100001
8159                                                      ldff1w.  */
8160                                                   return 1630;
8161                                                 }
8162                                               else
8163                                                 {
8164                                                   /* 33222222222211111111110000000000
8165                                                      10987654321098765432109876543210
8166                                                      xxxxxxxxxxxxx110xxxxx1x01x100001
8167                                                      ldff1w.  */
8168                                                   return 1631;
8169                                                 }
8170                                             }
8171                                           else
8172                                             {
8173                                               /* 33222222222211111111110000000000
8174                                                  10987654321098765432109876543210
8175                                                  xxxxxxxxxxxxx110xxxxxxx11x100001
8176                                                  prfd.  */
8177                                               return 1715;
8178                                             }
8179                                         }
8180                                       else
8181                                         {
8182                                           if (((word >> 22) & 0x1) == 0)
8183                                             {
8184                                               if (((word >> 21) & 0x1) == 0)
8185                                                 {
8186                                                   if (((word >> 23) & 0x1) == 0)
8187                                                     {
8188                                                       /* 33222222222211111111110000000000
8189                                                          10987654321098765432109876543210
8190                                                          xxxxxxxxxxxxx111xxxxx0001x100001
8191                                                          prfw.  */
8192                                                       return 1728;
8193                                                     }
8194                                                   else
8195                                                     {
8196                                                       /* 33222222222211111111110000000000
8197                                                          10987654321098765432109876543210
8198                                                          xxxxxxxxxxxxx111xxxxx0011x100001
8199                                                          prfd.  */
8200                                                       return 1714;
8201                                                     }
8202                                                 }
8203                                               else
8204                                                 {
8205                                                   /* 33222222222211111111110000000000
8206                                                      10987654321098765432109876543210
8207                                                      xxxxxxxxxxxxx111xxxxx10x1x100001
8208                                                      ldff1w.  */
8209                                                   return 1638;
8210                                                 }
8211                                             }
8212                                           else
8213                                             {
8214                                               if (((word >> 23) & 0x1) == 0)
8215                                                 {
8216                                                   /* 33222222222211111111110000000000
8217                                                      10987654321098765432109876543210
8218                                                      xxxxxxxxxxxxx111xxxxxx101x100001
8219                                                      ld1rw.  */
8220                                                   return 1513;
8221                                                 }
8222                                               else
8223                                                 {
8224                                                   /* 33222222222211111111110000000000
8225                                                      10987654321098765432109876543210
8226                                                      xxxxxxxxxxxxx111xxxxxx111x100001
8227                                                      ld1rd.  */
8228                                                   return 1494;
8229                                                 }
8230                                             }
8231                                         }
8232                                     }
8233                                 }
8234                             }
8235                         }
8236                       else
8237                         {
8238                           if (((word >> 13) & 0x1) == 0)
8239                             {
8240                               if (((word >> 14) & 0x1) == 0)
8241                                 {
8242                                   if (((word >> 15) & 0x1) == 0)
8243                                     {
8244                                       if (((word >> 21) & 0x1) == 0)
8245                                         {
8246                                           /* 33222222222211111111110000000000
8247                                              10987654321098765432109876543210
8248                                              xxxxxxxxxxxxx000xxxxx0xx1x10001x
8249                                              ld1sw.  */
8250                                           return 1538;
8251                                         }
8252                                       else
8253                                         {
8254                                           /* 33222222222211111111110000000000
8255                                              10987654321098765432109876543210
8256                                              xxxxxxxxxxxxx000xxxxx1xx1x10001x
8257                                              ld1sw.  */
8258                                           return 1539;
8259                                         }
8260                                     }
8261                                   else
8262                                     {
8263                                       if (((word >> 21) & 0x1) == 0)
8264                                         {
8265                                           /* 33222222222211111111110000000000
8266                                              10987654321098765432109876543210
8267                                              xxxxxxxxxxxxx001xxxxx0xx1x10001x
8268                                              ld1sw.  */
8269                                           return 1540;
8270                                         }
8271                                       else
8272                                         {
8273                                           if (((word >> 22) & 0x1) == 0)
8274                                             {
8275                                               /* 33222222222211111111110000000000
8276                                                  10987654321098765432109876543210
8277                                                  xxxxxxxxxxxxx001xxxxx10x1x10001x
8278                                                  ld1sw.  */
8279                                               return 1543;
8280                                             }
8281                                           else
8282                                             {
8283                                               /* 33222222222211111111110000000000
8284                                                  10987654321098765432109876543210
8285                                                  xxxxxxxxxxxxx001xxxxx11x1x10001x
8286                                                  ld1sw.  */
8287                                               return 1541;
8288                                             }
8289                                         }
8290                                     }
8291                                 }
8292                               else
8293                                 {
8294                                   if (((word >> 15) & 0x1) == 0)
8295                                     {
8296                                       if (((word >> 21) & 0x1) == 0)
8297                                         {
8298                                           if (((word >> 23) & 0x1) == 0)
8299                                             {
8300                                               /* 33222222222211111111110000000000
8301                                                  10987654321098765432109876543210
8302                                                  xxxxxxxxxxxxx010xxxxx0x01x10001x
8303                                                  ld1w.  */
8304                                               return 1548;
8305                                             }
8306                                           else
8307                                             {
8308                                               /* 33222222222211111111110000000000
8309                                                  10987654321098765432109876543210
8310                                                  xxxxxxxxxxxxx010xxxxx0x11x10001x
8311                                                  ld1d.  */
8312                                               return 1470;
8313                                             }
8314                                         }
8315                                       else
8316                                         {
8317                                           if (((word >> 23) & 0x1) == 0)
8318                                             {
8319                                               /* 33222222222211111111110000000000
8320                                                  10987654321098765432109876543210
8321                                                  xxxxxxxxxxxxx010xxxxx1x01x10001x
8322                                                  ld1w.  */
8323                                               return 1549;
8324                                             }
8325                                           else
8326                                             {
8327                                               /* 33222222222211111111110000000000
8328                                                  10987654321098765432109876543210
8329                                                  xxxxxxxxxxxxx010xxxxx1x11x10001x
8330                                                  ld1d.  */
8331                                               return 1471;
8332                                             }
8333                                         }
8334                                     }
8335                                   else
8336                                     {
8337                                       if (((word >> 21) & 0x1) == 0)
8338                                         {
8339                                           if (((word >> 23) & 0x1) == 0)
8340                                             {
8341                                               /* 33222222222211111111110000000000
8342                                                  10987654321098765432109876543210
8343                                                  xxxxxxxxxxxxx011xxxxx0x01x10001x
8344                                                  ld1w.  */
8345                                               return 1550;
8346                                             }
8347                                           else
8348                                             {
8349                                               /* 33222222222211111111110000000000
8350                                                  10987654321098765432109876543210
8351                                                  xxxxxxxxxxxxx011xxxxx0x11x10001x
8352                                                  ld1d.  */
8353                                               return 1472;
8354                                             }
8355                                         }
8356                                       else
8357                                         {
8358                                           if (((word >> 22) & 0x1) == 0)
8359                                             {
8360                                               if (((word >> 23) & 0x1) == 0)
8361                                                 {
8362                                                   /* 33222222222211111111110000000000
8363                                                      10987654321098765432109876543210
8364                                                      xxxxxxxxxxxxx011xxxxx1001x10001x
8365                                                      ld1w.  */
8366                                                   return 1555;
8367                                                 }
8368                                               else
8369                                                 {
8370                                                   /* 33222222222211111111110000000000
8371                                                      10987654321098765432109876543210
8372                                                      xxxxxxxxxxxxx011xxxxx1011x10001x
8373                                                      ld1d.  */
8374                                                   return 1475;
8375                                                 }
8376                                             }
8377                                           else
8378                                             {
8379                                               if (((word >> 23) & 0x1) == 0)
8380                                                 {
8381                                                   /* 33222222222211111111110000000000
8382                                                      10987654321098765432109876543210
8383                                                      xxxxxxxxxxxxx011xxxxx1101x10001x
8384                                                      ld1w.  */
8385                                                   return 1551;
8386                                                 }
8387                                               else
8388                                                 {
8389                                                   /* 33222222222211111111110000000000
8390                                                      10987654321098765432109876543210
8391                                                      xxxxxxxxxxxxx011xxxxx1111x10001x
8392                                                      ld1d.  */
8393                                                   return 1473;
8394                                                 }
8395                                             }
8396                                         }
8397                                     }
8398                                 }
8399                             }
8400                           else
8401                             {
8402                               if (((word >> 14) & 0x1) == 0)
8403                                 {
8404                                   if (((word >> 15) & 0x1) == 0)
8405                                     {
8406                                       if (((word >> 21) & 0x1) == 0)
8407                                         {
8408                                           /* 33222222222211111111110000000000
8409                                              10987654321098765432109876543210
8410                                              xxxxxxxxxxxxx100xxxxx0xx1x10001x
8411                                              ldff1sw.  */
8412                                           return 1625;
8413                                         }
8414                                       else
8415                                         {
8416                                           /* 33222222222211111111110000000000
8417                                              10987654321098765432109876543210
8418                                              xxxxxxxxxxxxx100xxxxx1xx1x10001x
8419                                              ldff1sw.  */
8420                                           return 1626;
8421                                         }
8422                                     }
8423                                   else
8424                                     {
8425                                       if (((word >> 21) & 0x1) == 0)
8426                                         {
8427                                           /* 33222222222211111111110000000000
8428                                              10987654321098765432109876543210
8429                                              xxxxxxxxxxxxx101xxxxx0xx1x10001x
8430                                              ldff1sw.  */
8431                                           return 1627;
8432                                         }
8433                                       else
8434                                         {
8435                                           if (((word >> 22) & 0x1) == 0)
8436                                             {
8437                                               /* 33222222222211111111110000000000
8438                                                  10987654321098765432109876543210
8439                                                  xxxxxxxxxxxxx101xxxxx10x1x10001x
8440                                                  ldff1sw.  */
8441                                               return 1629;
8442                                             }
8443                                           else
8444                                             {
8445                                               /* 33222222222211111111110000000000
8446                                                  10987654321098765432109876543210
8447                                                  xxxxxxxxxxxxx101xxxxx11x1x10001x
8448                                                  ldff1sw.  */
8449                                               return 1628;
8450                                             }
8451                                         }
8452                                     }
8453                                 }
8454                               else
8455                                 {
8456                                   if (((word >> 15) & 0x1) == 0)
8457                                     {
8458                                       if (((word >> 21) & 0x1) == 0)
8459                                         {
8460                                           if (((word >> 23) & 0x1) == 0)
8461                                             {
8462                                               /* 33222222222211111111110000000000
8463                                                  10987654321098765432109876543210
8464                                                  xxxxxxxxxxxxx110xxxxx0x01x10001x
8465                                                  ldff1w.  */
8466                                               return 1634;
8467                                             }
8468                                           else
8469                                             {
8470                                               /* 33222222222211111111110000000000
8471                                                  10987654321098765432109876543210
8472                                                  xxxxxxxxxxxxx110xxxxx0x11x10001x
8473                                                  ldff1d.  */
8474                                               return 1590;
8475                                             }
8476                                         }
8477                                       else
8478                                         {
8479                                           if (((word >> 23) & 0x1) == 0)
8480                                             {
8481                                               /* 33222222222211111111110000000000
8482                                                  10987654321098765432109876543210
8483                                                  xxxxxxxxxxxxx110xxxxx1x01x10001x
8484                                                  ldff1w.  */
8485                                               return 1635;
8486                                             }
8487                                           else
8488                                             {
8489                                               /* 33222222222211111111110000000000
8490                                                  10987654321098765432109876543210
8491                                                  xxxxxxxxxxxxx110xxxxx1x11x10001x
8492                                                  ldff1d.  */
8493                                               return 1591;
8494                                             }
8495                                         }
8496                                     }
8497                                   else
8498                                     {
8499                                       if (((word >> 21) & 0x1) == 0)
8500                                         {
8501                                           if (((word >> 22) & 0x1) == 0)
8502                                             {
8503                                               if (((word >> 23) & 0x1) == 0)
8504                                                 {
8505                                                   /* 33222222222211111111110000000000
8506                                                      10987654321098765432109876543210
8507                                                      xxxxxxxxxxxxx111xxxxx0001x10001x
8508                                                      prfw.  */
8509                                                   return 1730;
8510                                                 }
8511                                               else
8512                                                 {
8513                                                   /* 33222222222211111111110000000000
8514                                                      10987654321098765432109876543210
8515                                                      xxxxxxxxxxxxx111xxxxx0011x10001x
8516                                                      prfd.  */
8517                                                   return 1716;
8518                                                 }
8519                                             }
8520                                           else
8521                                             {
8522                                               if (((word >> 23) & 0x1) == 0)
8523                                                 {
8524                                                   /* 33222222222211111111110000000000
8525                                                      10987654321098765432109876543210
8526                                                      xxxxxxxxxxxxx111xxxxx0101x10001x
8527                                                      ldff1w.  */
8528                                                   return 1636;
8529                                                 }
8530                                               else
8531                                                 {
8532                                                   /* 33222222222211111111110000000000
8533                                                      10987654321098765432109876543210
8534                                                      xxxxxxxxxxxxx111xxxxx0111x10001x
8535                                                      ldff1d.  */
8536                                                   return 1592;
8537                                                 }
8538                                             }
8539                                         }
8540                                       else
8541                                         {
8542                                           if (((word >> 22) & 0x1) == 0)
8543                                             {
8544                                               if (((word >> 23) & 0x1) == 0)
8545                                                 {
8546                                                   /* 33222222222211111111110000000000
8547                                                      10987654321098765432109876543210
8548                                                      xxxxxxxxxxxxx111xxxxx1001x10001x
8549                                                      ldff1w.  */
8550                                                   return 1639;
8551                                                 }
8552                                               else
8553                                                 {
8554                                                   /* 33222222222211111111110000000000
8555                                                      10987654321098765432109876543210
8556                                                      xxxxxxxxxxxxx111xxxxx1011x10001x
8557                                                      ldff1d.  */
8558                                                   return 1594;
8559                                                 }
8560                                             }
8561                                           else
8562                                             {
8563                                               if (((word >> 23) & 0x1) == 0)
8564                                                 {
8565                                                   /* 33222222222211111111110000000000
8566                                                      10987654321098765432109876543210
8567                                                      xxxxxxxxxxxxx111xxxxx1101x10001x
8568                                                      ldff1w.  */
8569                                                   return 1637;
8570                                                 }
8571                                               else
8572                                                 {
8573                                                   /* 33222222222211111111110000000000
8574                                                      10987654321098765432109876543210
8575                                                      xxxxxxxxxxxxx111xxxxx1111x10001x
8576                                                      ldff1d.  */
8577                                                   return 1593;
8578                                                 }
8579                                             }
8580                                         }
8581                                     }
8582                                 }
8583                             }
8584                         }
8585                     }
8586                   else
8587                     {
8588                       if (((word >> 15) & 0x1) == 0)
8589                         {
8590                           if (((word >> 14) & 0x1) == 0)
8591                             {
8592                               if (((word >> 13) & 0x1) == 0)
8593                                 {
8594                                   if (((word >> 30) & 0x1) == 0)
8595                                     {
8596                                       if (((word >> 21) & 0x1) == 0)
8597                                         {
8598                                           if (((word >> 31) & 0x1) == 0)
8599                                             {
8600                                               if (((word >> 4) & 0x1) == 0)
8601                                                 {
8602                                                   /* 33222222222211111111110000000000
8603                                                      10987654321098765432109876543210
8604                                                      xxxx0xxxxxxxx000xxxxx0xx1x100100
8605                                                      cmpge.  */
8606                                                   return 1278;
8607                                                 }
8608                                               else
8609                                                 {
8610                                                   /* 33222222222211111111110000000000
8611                                                      10987654321098765432109876543210
8612                                                      xxxx1xxxxxxxx000xxxxx0xx1x100100
8613                                                      cmpgt.  */
8614                                                   return 1281;
8615                                                 }
8616                                             }
8617                                           else
8618                                             {
8619                                               if (((word >> 23) & 0x1) == 0)
8620                                                 {
8621                                                   /* 33222222222211111111110000000000
8622                                                      10987654321098765432109876543210
8623                                                      xxxxxxxxxxxxx000xxxxx0x01x100101
8624                                                      ld1rqw.  */
8625                                                   return 1505;
8626                                                 }
8627                                               else
8628                                                 {
8629                                                   /* 33222222222211111111110000000000
8630                                                      10987654321098765432109876543210
8631                                                      xxxxxxxxxxxxx000xxxxx0x11x100101
8632                                                      ld1rqd.  */
8633                                                   return 1501;
8634                                                 }
8635                                             }
8636                                         }
8637                                       else
8638                                         {
8639                                           if (((word >> 4) & 0x1) == 0)
8640                                             {
8641                                               if (((word >> 11) & 0x1) == 0)
8642                                                 {
8643                                                   if (((word >> 12) & 0x1) == 0)
8644                                                     {
8645                                                       /* 33222222222211111111110000000000
8646                                                          10987654321098765432109876543210
8647                                                          xxxx0xxxxxx00000xxxxx1xx1x10010x
8648                                                          whilelt.  */
8649                                                       return 1966;
8650                                                     }
8651                                                   else
8652                                                     {
8653                                                       /* 33222222222211111111110000000000
8654                                                          10987654321098765432109876543210
8655                                                          xxxx0xxxxxx01000xxxxx1xx1x10010x
8656                                                          whilelt.  */
8657                                                       return 1967;
8658                                                     }
8659                                                 }
8660                                               else
8661                                                 {
8662                                                   if (((word >> 12) & 0x1) == 0)
8663                                                     {
8664                                                       /* 33222222222211111111110000000000
8665                                                          10987654321098765432109876543210
8666                                                          xxxx0xxxxxx10000xxxxx1xx1x10010x
8667                                                          whilelo.  */
8668                                                       return 1962;
8669                                                     }
8670                                                   else
8671                                                     {
8672                                                       /* 33222222222211111111110000000000
8673                                                          10987654321098765432109876543210
8674                                                          xxxx0xxxxxx11000xxxxx1xx1x10010x
8675                                                          whilelo.  */
8676                                                       return 1963;
8677                                                     }
8678                                                 }
8679                                             }
8680                                           else
8681                                             {
8682                                               if (((word >> 11) & 0x1) == 0)
8683                                                 {
8684                                                   if (((word >> 12) & 0x1) == 0)
8685                                                     {
8686                                                       /* 33222222222211111111110000000000
8687                                                          10987654321098765432109876543210
8688                                                          xxxx1xxxxxx00000xxxxx1xx1x10010x
8689                                                          whilele.  */
8690                                                       return 1960;
8691                                                     }
8692                                                   else
8693                                                     {
8694                                                       /* 33222222222211111111110000000000
8695                                                          10987654321098765432109876543210
8696                                                          xxxx1xxxxxx01000xxxxx1xx1x10010x
8697                                                          whilele.  */
8698                                                       return 1961;
8699                                                     }
8700                                                 }
8701                                               else
8702                                                 {
8703                                                   if (((word >> 12) & 0x1) == 0)
8704                                                     {
8705                                                       /* 33222222222211111111110000000000
8706                                                          10987654321098765432109876543210
8707                                                          xxxx1xxxxxx10000xxxxx1xx1x10010x
8708                                                          whilels.  */
8709                                                       return 1964;
8710                                                     }
8711                                                   else
8712                                                     {
8713                                                       /* 33222222222211111111110000000000
8714                                                          10987654321098765432109876543210
8715                                                          xxxx1xxxxxx11000xxxxx1xx1x10010x
8716                                                          whilels.  */
8717                                                       return 1965;
8718                                                     }
8719                                                 }
8720                                             }
8721                                         }
8722                                     }
8723                                   else
8724                                     {
8725                                       if (((word >> 31) & 0x1) == 0)
8726                                         {
8727                                           if (((word >> 21) & 0x1) == 0)
8728                                             {
8729                                               if (((word >> 10) & 0x1) == 0)
8730                                                 {
8731                                                   if (((word >> 11) & 0x1) == 0)
8732                                                     {
8733                                                       /* 33222222222211111111110000000000
8734                                                          10987654321098765432109876543210
8735                                                          xxxxxxxxxx00x000xxxxx0xx1x100110
8736                                                          fadd.  */
8737                                                       return 1336;
8738                                                     }
8739                                                   else
8740                                                     {
8741                                                       if (((word >> 12) & 0x1) == 0)
8742                                                         {
8743                                                           /* 33222222222211111111110000000000
8744                                                              10987654321098765432109876543210
8745                                                              xxxxxxxxxx010000xxxxx0xx1x100110
8746                                                              fmul.  */
8747                                                           return 1403;
8748                                                         }
8749                                                       else
8750                                                         {
8751                                                           /* 33222222222211111111110000000000
8752                                                              10987654321098765432109876543210
8753                                                              xxxxxxxxxx011000xxxxx0xx1x100110
8754                                                              frecps.  */
8755                                                           return 1416;
8756                                                         }
8757                                                     }
8758                                                 }
8759                                               else
8760                                                 {
8761                                                   if (((word >> 11) & 0x1) == 0)
8762                                                     {
8763                                                       /* 33222222222211111111110000000000
8764                                                          10987654321098765432109876543210
8765                                                          xxxxxxxxxx10x000xxxxx0xx1x100110
8766                                                          fsub.  */
8767                                                       return 1429;
8768                                                     }
8769                                                   else
8770                                                     {
8771                                                       if (((word >> 12) & 0x1) == 0)
8772                                                         {
8773                                                           /* 33222222222211111111110000000000
8774                                                              10987654321098765432109876543210
8775                                                              xxxxxxxxxx110000xxxxx0xx1x100110
8776                                                              ftsmul.  */
8777                                                           return 1435;
8778                                                         }
8779                                                       else
8780                                                         {
8781                                                           /* 33222222222211111111110000000000
8782                                                              10987654321098765432109876543210
8783                                                              xxxxxxxxxx111000xxxxx0xx1x100110
8784                                                              frsqrts.  */
8785                                                           return 1426;
8786                                                         }
8787                                                     }
8788                                                 }
8789                                             }
8790                                           else
8791                                             {
8792                                               /* 33222222222211111111110000000000
8793                                                  10987654321098765432109876543210
8794                                                  xxxxxxxxxxxxx000xxxxx1xx1x100110
8795                                                  fmla.  */
8796                                               return 1394;
8797                                             }
8798                                         }
8799                                       else
8800                                         {
8801                                           /* 33222222222211111111110000000000
8802                                              10987654321098765432109876543210
8803                                              xxxxxxxxxxxxx000xxxxxxxx1x100111
8804                                              str.  */
8805                                           return 1881;
8806                                         }
8807                                     }
8808                                 }
8809                               else
8810                                 {
8811                                   if (((word >> 21) & 0x1) == 0)
8812                                     {
8813                                       if (((word >> 30) & 0x1) == 0)
8814                                         {
8815                                           if (((word >> 31) & 0x1) == 0)
8816                                             {
8817                                               if (((word >> 4) & 0x1) == 0)
8818                                                 {
8819                                                   /* 33222222222211111111110000000000
8820                                                      10987654321098765432109876543210
8821                                                      xxxx0xxxxxxxx100xxxxx0xx1x100100
8822                                                      cmplt.  */
8823                                                   return 1295;
8824                                                 }
8825                                               else
8826                                                 {
8827                                                   /* 33222222222211111111110000000000
8828                                                      10987654321098765432109876543210
8829                                                      xxxx1xxxxxxxx100xxxxx0xx1x100100
8830                                                      cmple.  */
8831                                                   return 1289;
8832                                                 }
8833                                             }
8834                                           else
8835                                             {
8836                                               if (((word >> 23) & 0x1) == 0)
8837                                                 {
8838                                                   /* 33222222222211111111110000000000
8839                                                      10987654321098765432109876543210
8840                                                      xxxxxxxxxxxxx100xxxxx0x01x100101
8841                                                      ld1rqw.  */
8842                                                   return 1504;
8843                                                 }
8844                                               else
8845                                                 {
8846                                                   /* 33222222222211111111110000000000
8847                                                      10987654321098765432109876543210
8848                                                      xxxxxxxxxxxxx100xxxxx0x11x100101
8849                                                      ld1rqd.  */
8850                                                   return 1500;
8851                                                 }
8852                                             }
8853                                         }
8854                                       else
8855                                         {
8856                                           if (((word >> 16) & 0x1) == 0)
8857                                             {
8858                                               if (((word >> 17) & 0x1) == 0)
8859                                                 {
8860                                                   if (((word >> 18) & 0x1) == 0)
8861                                                     {
8862                                                       if (((word >> 19) & 0x1) == 0)
8863                                                         {
8864                                                           if (((word >> 20) & 0x1) == 0)
8865                                                             {
8866                                                               /* 33222222222211111111110000000000
8867                                                                  10987654321098765432109876543210
8868                                                                  xxxxxxxxxxxxx100000000xx1x10011x
8869                                                                  faddv.  */
8870                                                               return 1340;
8871                                                             }
8872                                                           else
8873                                                             {
8874                                                               if (((word >> 4) & 0x1) == 0)
8875                                                                 {
8876                                                                   /* 33222222222211111111110000000000
8877                                                                      10987654321098765432109876543210
8878                                                                      xxxx0xxxxxxxx100000010xx1x10011x
8879                                                                      fcmge.  */
8880                                                                   return 1347;
8881                                                                 }
8882                                                               else
8883                                                                 {
8884                                                                   /* 33222222222211111111110000000000
8885                                                                      10987654321098765432109876543210
8886                                                                      xxxx1xxxxxxxx100000010xx1x10011x
8887                                                                      fcmgt.  */
8888                                                                   return 1349;
8889                                                                 }
8890                                                             }
8891                                                         }
8892                                                       else
8893                                                         {
8894                                                           /* 33222222222211111111110000000000
8895                                                              10987654321098765432109876543210
8896                                                              xxxxxxxxxxxxx1000001x0xx1x10011x
8897                                                              fadda.  */
8898                                                           return 1339;
8899                                                         }
8900                                                     }
8901                                                   else
8902                                                     {
8903                                                       /* 33222222222211111111110000000000
8904                                                          10987654321098765432109876543210
8905                                                          xxxxxxxxxxxxx100001xx0xx1x10011x
8906                                                          fmaxnmv.  */
8907                                                       return 1386;
8908                                                     }
8909                                                 }
8910                                               else
8911                                                 {
8912                                                   if (((word >> 18) & 0x1) == 0)
8913                                                     {
8914                                                       /* 33222222222211111111110000000000
8915                                                          10987654321098765432109876543210
8916                                                          xxxxxxxxxxxxx100010xx0xx1x10011x
8917                                                          fcmeq.  */
8918                                                       return 1345;
8919                                                     }
8920                                                   else
8921                                                     {
8922                                                       if (((word >> 19) & 0x1) == 0)
8923                                                         {
8924                                                           /* 33222222222211111111110000000000
8925                                                              10987654321098765432109876543210
8926                                                              xxxxxxxxxxxxx1000110x0xx1x10011x
8927                                                              fmaxv.  */
8928                                                           return 1387;
8929                                                         }
8930                                                       else
8931                                                         {
8932                                                           /* 33222222222211111111110000000000
8933                                                              10987654321098765432109876543210
8934                                                              xxxxxxxxxxxxx1000111x0xx1x10011x
8935                                                              frecpe.  */
8936                                                           return 1415;
8937                                                         }
8938                                                     }
8939                                                 }
8940                                             }
8941                                           else
8942                                             {
8943                                               if (((word >> 17) & 0x1) == 0)
8944                                                 {
8945                                                   if (((word >> 18) & 0x1) == 0)
8946                                                     {
8947                                                       if (((word >> 4) & 0x1) == 0)
8948                                                         {
8949                                                           /* 33222222222211111111110000000000
8950                                                              10987654321098765432109876543210
8951                                                              xxxx0xxxxxxxx100100xx0xx1x10011x
8952                                                              fcmlt.  */
8953                                                           return 1352;
8954                                                         }
8955                                                       else
8956                                                         {
8957                                                           /* 33222222222211111111110000000000
8958                                                              10987654321098765432109876543210
8959                                                              xxxx1xxxxxxxx100100xx0xx1x10011x
8960                                                              fcmle.  */
8961                                                           return 1351;
8962                                                         }
8963                                                     }
8964                                                   else
8965                                                     {
8966                                                       /* 33222222222211111111110000000000
8967                                                          10987654321098765432109876543210
8968                                                          xxxxxxxxxxxxx100101xx0xx1x10011x
8969                                                          fminnmv.  */
8970                                                       return 1392;
8971                                                     }
8972                                                 }
8973                                               else
8974                                                 {
8975                                                   if (((word >> 18) & 0x1) == 0)
8976                                                     {
8977                                                       /* 33222222222211111111110000000000
8978                                                          10987654321098765432109876543210
8979                                                          xxxxxxxxxxxxx100110xx0xx1x10011x
8980                                                          fcmne.  */
8981                                                       return 1353;
8982                                                     }
8983                                                   else
8984                                                     {
8985                                                       if (((word >> 19) & 0x1) == 0)
8986                                                         {
8987                                                           /* 33222222222211111111110000000000
8988                                                              10987654321098765432109876543210
8989                                                              xxxxxxxxxxxxx1001110x0xx1x10011x
8990                                                              fminv.  */
8991                                                           return 1393;
8992                                                         }
8993                                                       else
8994                                                         {
8995                                                           /* 33222222222211111111110000000000
8996                                                              10987654321098765432109876543210
8997                                                              xxxxxxxxxxxxx1001111x0xx1x10011x
8998                                                              frsqrte.  */
8999                                                           return 1425;
9000                                                         }
9001                                                     }
9002                                                 }
9003                                             }
9004                                         }
9005                                     }
9006                                   else
9007                                     {
9008                                       if (((word >> 30) & 0x1) == 0)
9009                                         {
9010                                           if (((word >> 4) & 0x1) == 0)
9011                                             {
9012                                               /* 33222222222211111111110000000000
9013                                                  10987654321098765432109876543210
9014                                                  xxxx0xxxxxxxx100xxxxx1xx1x10010x
9015                                                  ctermeq.  */
9016                                               return 1310;
9017                                             }
9018                                           else
9019                                             {
9020                                               /* 33222222222211111111110000000000
9021                                                  10987654321098765432109876543210
9022                                                  xxxx1xxxxxxxx100xxxxx1xx1x10010x
9023                                                  ctermne.  */
9024                                               return 1311;
9025                                             }
9026                                         }
9027                                       else
9028                                         {
9029                                           /* 33222222222211111111110000000000
9030                                              10987654321098765432109876543210
9031                                              xxxxxxxxxxxxx100xxxxx1xx1x10011x
9032                                              fmls.  */
9033                                           return 1398;
9034                                         }
9035                                     }
9036                                 }
9037                             }
9038                           else
9039                             {
9040                               if (((word >> 30) & 0x1) == 0)
9041                                 {
9042                                   if (((word >> 21) & 0x1) == 0)
9043                                     {
9044                                       if (((word >> 22) & 0x1) == 0)
9045                                         {
9046                                           if (((word >> 23) & 0x1) == 0)
9047                                             {
9048                                               if (((word >> 31) & 0x1) == 0)
9049                                                 {
9050                                                   if (((word >> 9) & 0x1) == 0)
9051                                                     {
9052                                                       if (((word >> 20) & 0x1) == 0)
9053                                                         {
9054                                                           if (((word >> 4) & 0x1) == 0)
9055                                                             {
9056                                                               /* 33222222222211111111110000000000
9057                                                                  10987654321098765432109876543210
9058                                                                  xxxx0xxxx0xxxx10xxxx00001x100100
9059                                                                  and.  */
9060                                                               return 1241;
9061                                                             }
9062                                                           else
9063                                                             {
9064                                                               /* 33222222222211111111110000000000
9065                                                                  10987654321098765432109876543210
9066                                                                  xxxx1xxxx0xxxx10xxxx00001x100100
9067                                                                  bic.  */
9068                                                               return 1253;
9069                                                             }
9070                                                         }
9071                                                       else
9072                                                         {
9073                                                           if (((word >> 19) & 0x1) == 0)
9074                                                             {
9075                                                               /* 33222222222211111111110000000000
9076                                                                  10987654321098765432109876543210
9077                                                                  xxxxxxxxx0xxxx10xxx010001x100100
9078                                                                  brka.  */
9079                                                               return 1255;
9080                                                             }
9081                                                           else
9082                                                             {
9083                                                               /* 33222222222211111111110000000000
9084                                                                  10987654321098765432109876543210
9085                                                                  xxxxxxxxx0xxxx10xxx110001x100100
9086                                                                  brkn.  */
9087                                                               return 1259;
9088                                                             }
9089                                                         }
9090                                                     }
9091                                                   else
9092                                                     {
9093                                                       if (((word >> 4) & 0x1) == 0)
9094                                                         {
9095                                                           /* 33222222222211111111110000000000
9096                                                              10987654321098765432109876543210
9097                                                              xxxx0xxxx1xxxx10xxxxx0001x100100
9098                                                              eor.  */
9099                                                           return 1328;
9100                                                         }
9101                                                       else
9102                                                         {
9103                                                           /* 33222222222211111111110000000000
9104                                                              10987654321098765432109876543210
9105                                                              xxxx1xxxx1xxxx10xxxxx0001x100100
9106                                                              sel.  */
9107                                                           return 1761;
9108                                                         }
9109                                                     }
9110                                                 }
9111                                               else
9112                                                 {
9113                                                   if (((word >> 13) & 0x1) == 0)
9114                                                     {
9115                                                       /* 33222222222211111111110000000000
9116                                                          10987654321098765432109876543210
9117                                                          xxxxxxxxxxxxx010xxxxx0001x100101
9118                                                          ld1sh.  */
9119                                                       return 1527;
9120                                                     }
9121                                                   else
9122                                                     {
9123                                                       /* 33222222222211111111110000000000
9124                                                          10987654321098765432109876543210
9125                                                          xxxxxxxxxxxxx110xxxxx0001x100101
9126                                                          ldff1sh.  */
9127                                                       return 1616;
9128                                                     }
9129                                                 }
9130                                             }
9131                                           else
9132                                             {
9133                                               if (((word >> 31) & 0x1) == 0)
9134                                                 {
9135                                                   if (((word >> 9) & 0x1) == 0)
9136                                                     {
9137                                                       if (((word >> 20) & 0x1) == 0)
9138                                                         {
9139                                                           if (((word >> 4) & 0x1) == 0)
9140                                                             {
9141                                                               /* 33222222222211111111110000000000
9142                                                                  10987654321098765432109876543210
9143                                                                  xxxx0xxxx0xxxx10xxxx00011x100100
9144                                                                  orr.  */
9145                                                               return 1697;
9146                                                             }
9147                                                           else
9148                                                             {
9149                                                               /* 33222222222211111111110000000000
9150                                                                  10987654321098765432109876543210
9151                                                                  xxxx1xxxx0xxxx10xxxx00011x100100
9152                                                                  orn.  */
9153                                                               return 1692;
9154                                                             }
9155                                                         }
9156                                                       else
9157                                                         {
9158                                                           /* 33222222222211111111110000000000
9159                                                              10987654321098765432109876543210
9160                                                              xxxxxxxxx0xxxx10xxxx10011x100100
9161                                                              brkb.  */
9162                                                           return 1257;
9163                                                         }
9164                                                     }
9165                                                   else
9166                                                     {
9167                                                       if (((word >> 4) & 0x1) == 0)
9168                                                         {
9169                                                           /* 33222222222211111111110000000000
9170                                                              10987654321098765432109876543210
9171                                                              xxxx0xxxx1xxxx10xxxxx0011x100100
9172                                                              nor.  */
9173                                                           return 1689;
9174                                                         }
9175                                                       else
9176                                                         {
9177                                                           /* 33222222222211111111110000000000
9178                                                              10987654321098765432109876543210
9179                                                              xxxx1xxxx1xxxx10xxxxx0011x100100
9180                                                              nand.  */
9181                                                           return 1686;
9182                                                         }
9183                                                     }
9184                                                 }
9185                                               else
9186                                                 {
9187                                                   if (((word >> 13) & 0x1) == 0)
9188                                                     {
9189                                                       /* 33222222222211111111110000000000
9190                                                          10987654321098765432109876543210
9191                                                          xxxxxxxxxxxxx010xxxxx0011x100101
9192                                                          ld1sb.  */
9193                                                       return 1515;
9194                                                     }
9195                                                   else
9196                                                     {
9197                                                       /* 33222222222211111111110000000000
9198                                                          10987654321098765432109876543210
9199                                                          xxxxxxxxxxxxx110xxxxx0011x100101
9200                                                          ldff1sb.  */
9201                                                       return 1607;
9202                                                     }
9203                                                 }
9204                                             }
9205                                         }
9206                                       else
9207                                         {
9208                                           if (((word >> 23) & 0x1) == 0)
9209                                             {
9210                                               if (((word >> 31) & 0x1) == 0)
9211                                                 {
9212                                                   if (((word >> 4) & 0x1) == 0)
9213                                                     {
9214                                                       if (((word >> 9) & 0x1) == 0)
9215                                                         {
9216                                                           if (((word >> 20) & 0x1) == 0)
9217                                                             {
9218                                                               /* 33222222222211111111110000000000
9219                                                                  10987654321098765432109876543210
9220                                                                  xxxx0xxxx0xxxx10xxxx00101x100100
9221                                                                  ands.  */
9222                                                               return 1242;
9223                                                             }
9224                                                           else
9225                                                             {
9226                                                               if (((word >> 19) & 0x1) == 0)
9227                                                                 {
9228                                                                   /* 33222222222211111111110000000000
9229                                                                      10987654321098765432109876543210
9230                                                                      xxxx0xxxx0xxxx10xxx010101x100100
9231                                                                      brkas.  */
9232                                                                   return 1256;
9233                                                                 }
9234                                                               else
9235                                                                 {
9236                                                                   /* 33222222222211111111110000000000
9237                                                                      10987654321098765432109876543210
9238                                                                      xxxx0xxxx0xxxx10xxx110101x100100
9239                                                                      brkns.  */
9240                                                                   return 1260;
9241                                                                 }
9242                                                             }
9243                                                         }
9244                                                       else
9245                                                         {
9246                                                           /* 33222222222211111111110000000000
9247                                                              10987654321098765432109876543210
9248                                                              xxxx0xxxx1xxxx10xxxxx0101x100100
9249                                                              eors.  */
9250                                                           return 1329;
9251                                                         }
9252                                                     }
9253                                                   else
9254                                                     {
9255                                                       /* 33222222222211111111110000000000
9256                                                          10987654321098765432109876543210
9257                                                          xxxx1xxxxxxxxx10xxxxx0101x100100
9258                                                          bics.  */
9259                                                       return 1254;
9260                                                     }
9261                                                 }
9262                                               else
9263                                                 {
9264                                                   if (((word >> 13) & 0x1) == 0)
9265                                                     {
9266                                                       /* 33222222222211111111110000000000
9267                                                          10987654321098765432109876543210
9268                                                          xxxxxxxxxxxxx010xxxxx0101x100101
9269                                                          ld1w.  */
9270                                                       return 1546;
9271                                                     }
9272                                                   else
9273                                                     {
9274                                                       /* 33222222222211111111110000000000
9275                                                          10987654321098765432109876543210
9276                                                          xxxxxxxxxxxxx110xxxxx0101x100101
9277                                                          ldff1w.  */
9278                                                       return 1632;
9279                                                     }
9280                                                 }
9281                                             }
9282                                           else
9283                                             {
9284                                               if (((word >> 31) & 0x1) == 0)
9285                                                 {
9286                                                   if (((word >> 4) & 0x1) == 0)
9287                                                     {
9288                                                       if (((word >> 9) & 0x1) == 0)
9289                                                         {
9290                                                           if (((word >> 20) & 0x1) == 0)
9291                                                             {
9292                                                               /* 33222222222211111111110000000000
9293                                                                  10987654321098765432109876543210
9294                                                                  xxxx0xxxx0xxxx10xxxx00111x100100
9295                                                                  orrs.  */
9296                                                               return 1698;
9297                                                             }
9298                                                           else
9299                                                             {
9300                                                               /* 33222222222211111111110000000000
9301                                                                  10987654321098765432109876543210
9302                                                                  xxxx0xxxx0xxxx10xxxx10111x100100
9303                                                                  brkbs.  */
9304                                                               return 1258;
9305                                                             }
9306                                                         }
9307                                                       else
9308                                                         {
9309                                                           /* 33222222222211111111110000000000
9310                                                              10987654321098765432109876543210
9311                                                              xxxx0xxxx1xxxx10xxxxx0111x100100
9312                                                              nors.  */
9313                                                           return 1690;
9314                                                         }
9315                                                     }
9316                                                   else
9317                                                     {
9318                                                       if (((word >> 9) & 0x1) == 0)
9319                                                         {
9320                                                           /* 33222222222211111111110000000000
9321                                                              10987654321098765432109876543210
9322                                                              xxxx1xxxx0xxxx10xxxxx0111x100100
9323                                                              orns.  */
9324                                                           return 1693;
9325                                                         }
9326                                                       else
9327                                                         {
9328                                                           /* 33222222222211111111110000000000
9329                                                              10987654321098765432109876543210
9330                                                              xxxx1xxxx1xxxx10xxxxx0111x100100
9331                                                              nands.  */
9332                                                           return 1687;
9333                                                         }
9334                                                     }
9335                                                 }
9336                                               else
9337                                                 {
9338                                                   if (((word >> 13) & 0x1) == 0)
9339                                                     {
9340                                                       /* 33222222222211111111110000000000
9341                                                          10987654321098765432109876543210
9342                                                          xxxxxxxxxxxxx010xxxxx0111x100101
9343                                                          ld1sb.  */
9344                                                       return 1517;
9345                                                     }
9346                                                   else
9347                                                     {
9348                                                       /* 33222222222211111111110000000000
9349                                                          10987654321098765432109876543210
9350                                                          xxxxxxxxxxxxx110xxxxx0111x100101
9351                                                          ldff1sb.  */
9352                                                       return 1609;
9353                                                     }
9354                                                 }
9355                                             }
9356                                         }
9357                                     }
9358                                   else
9359                                     {
9360                                       if (((word >> 13) & 0x1) == 0)
9361                                         {
9362                                           if (((word >> 22) & 0x1) == 0)
9363                                             {
9364                                               if (((word >> 23) & 0x1) == 0)
9365                                                 {
9366                                                   /* 33222222222211111111110000000000
9367                                                      10987654321098765432109876543210
9368                                                      xxxxxxxxxxxxx010xxxxx1001x10010x
9369                                                      ld1sh.  */
9370                                                   return 1528;
9371                                                 }
9372                                               else
9373                                                 {
9374                                                   /* 33222222222211111111110000000000
9375                                                      10987654321098765432109876543210
9376                                                      xxxxxxxxxxxxx010xxxxx1011x10010x
9377                                                      ld1sb.  */
9378                                                   return 1516;
9379                                                 }
9380                                             }
9381                                           else
9382                                             {
9383                                               if (((word >> 23) & 0x1) == 0)
9384                                                 {
9385                                                   /* 33222222222211111111110000000000
9386                                                      10987654321098765432109876543210
9387                                                      xxxxxxxxxxxxx010xxxxx1101x10010x
9388                                                      ld1w.  */
9389                                                   return 1547;
9390                                                 }
9391                                               else
9392                                                 {
9393                                                   /* 33222222222211111111110000000000
9394                                                      10987654321098765432109876543210
9395                                                      xxxxxxxxxxxxx010xxxxx1111x10010x
9396                                                      ld1d.  */
9397                                                   return 1469;
9398                                                 }
9399                                             }
9400                                         }
9401                                       else
9402                                         {
9403                                           if (((word >> 22) & 0x1) == 0)
9404                                             {
9405                                               if (((word >> 23) & 0x1) == 0)
9406                                                 {
9407                                                   /* 33222222222211111111110000000000
9408                                                      10987654321098765432109876543210
9409                                                      xxxxxxxxxxxxx110xxxxx1001x10010x
9410                                                      ldff1sh.  */
9411                                                   return 1617;
9412                                                 }
9413                                               else
9414                                                 {
9415                                                   /* 33222222222211111111110000000000
9416                                                      10987654321098765432109876543210
9417                                                      xxxxxxxxxxxxx110xxxxx1011x10010x
9418                                                      ldff1sb.  */
9419                                                   return 1608;
9420                                                 }
9421                                             }
9422                                           else
9423                                             {
9424                                               if (((word >> 23) & 0x1) == 0)
9425                                                 {
9426                                                   /* 33222222222211111111110000000000
9427                                                      10987654321098765432109876543210
9428                                                      xxxxxxxxxxxxx110xxxxx1101x10010x
9429                                                      ldff1w.  */
9430                                                   return 1633;
9431                                                 }
9432                                               else
9433                                                 {
9434                                                   /* 33222222222211111111110000000000
9435                                                      10987654321098765432109876543210
9436                                                      xxxxxxxxxxxxx110xxxxx1111x10010x
9437                                                      ldff1d.  */
9438                                                   return 1589;
9439                                                 }
9440                                             }
9441                                         }
9442                                     }
9443                                 }
9444                               else
9445                                 {
9446                                   if (((word >> 13) & 0x1) == 0)
9447                                     {
9448                                       if (((word >> 31) & 0x1) == 0)
9449                                         {
9450                                           if (((word >> 21) & 0x1) == 0)
9451                                             {
9452                                               if (((word >> 4) & 0x1) == 0)
9453                                                 {
9454                                                   /* 33222222222211111111110000000000
9455                                                      10987654321098765432109876543210
9456                                                      xxxx0xxxxxxxx010xxxxx0xx1x100110
9457                                                      fcmge.  */
9458                                                   return 1348;
9459                                                 }
9460                                               else
9461                                                 {
9462                                                   /* 33222222222211111111110000000000
9463                                                      10987654321098765432109876543210
9464                                                      xxxx1xxxxxxxx010xxxxx0xx1x100110
9465                                                      fcmgt.  */
9466                                                   return 1350;
9467                                                 }
9468                                             }
9469                                           else
9470                                             {
9471                                               /* 33222222222211111111110000000000
9472                                                  10987654321098765432109876543210
9473                                                  xxxxxxxxxxxxx010xxxxx1xx1x100110
9474                                                  fnmla.  */
9475                                               return 1412;
9476                                             }
9477                                         }
9478                                       else
9479                                         {
9480                                           if (((word >> 22) & 0x1) == 0)
9481                                             {
9482                                               /* 33222222222211111111110000000000
9483                                                  10987654321098765432109876543210
9484                                                  xxxxxxxxxxxxx010xxxxxx0x1x100111
9485                                                  str.  */
9486                                               return 1882;
9487                                             }
9488                                           else
9489                                             {
9490                                               if (((word >> 21) & 0x1) == 0)
9491                                                 {
9492                                                   /* 33222222222211111111110000000000
9493                                                      10987654321098765432109876543210
9494                                                      xxxxxxxxxxxxx010xxxxx01x1x100111
9495                                                      st1w.  */
9496                                                   return 1841;
9497                                                 }
9498                                               else
9499                                                 {
9500                                                   if (((word >> 23) & 0x1) == 0)
9501                                                     {
9502                                                       /* 33222222222211111111110000000000
9503                                                          10987654321098765432109876543210
9504                                                          xxxxxxxxxxxxx010xxxxx1101x100111
9505                                                          st1w.  */
9506                                                       return 1843;
9507                                                     }
9508                                                   else
9509                                                     {
9510                                                       /* 33222222222211111111110000000000
9511                                                          10987654321098765432109876543210
9512                                                          xxxxxxxxxxxxx010xxxxx1111x100111
9513                                                          st1d.  */
9514                                                       return 1820;
9515                                                     }
9516                                                 }
9517                                             }
9518                                         }
9519                                     }
9520                                   else
9521                                     {
9522                                       if (((word >> 21) & 0x1) == 0)
9523                                         {
9524                                           if (((word >> 31) & 0x1) == 0)
9525                                             {
9526                                               if (((word >> 4) & 0x1) == 0)
9527                                                 {
9528                                                   /* 33222222222211111111110000000000
9529                                                      10987654321098765432109876543210
9530                                                      xxxx0xxxxxxxx110xxxxx0xx1x100110
9531                                                      fcmeq.  */
9532                                                   return 1346;
9533                                                 }
9534                                               else
9535                                                 {
9536                                                   /* 33222222222211111111110000000000
9537                                                      10987654321098765432109876543210
9538                                                      xxxx1xxxxxxxx110xxxxx0xx1x100110
9539                                                      fcmne.  */
9540                                                   return 1354;
9541                                                 }
9542                                             }
9543                                           else
9544                                             {
9545                                               if (((word >> 22) & 0x1) == 0)
9546                                                 {
9547                                                   if (((word >> 23) & 0x1) == 0)
9548                                                     {
9549                                                       /* 33222222222211111111110000000000
9550                                                          10987654321098765432109876543210
9551                                                          xxxxxxxxxxxxx110xxxxx0001x100111
9552                                                          stnt1w.  */
9553                                                       return 1879;
9554                                                     }
9555                                                   else
9556                                                     {
9557                                                       /* 33222222222211111111110000000000
9558                                                          10987654321098765432109876543210
9559                                                          xxxxxxxxxxxxx110xxxxx0011x100111
9560                                                          stnt1d.  */
9561                                                       return 1875;
9562                                                     }
9563                                                 }
9564                                               else
9565                                                 {
9566                                                   if (((word >> 23) & 0x1) == 0)
9567                                                     {
9568                                                       /* 33222222222211111111110000000000
9569                                                          10987654321098765432109876543210
9570                                                          xxxxxxxxxxxxx110xxxxx0101x100111
9571                                                          st3w.  */
9572                                                       return 1863;
9573                                                     }
9574                                                   else
9575                                                     {
9576                                                       /* 33222222222211111111110000000000
9577                                                          10987654321098765432109876543210
9578                                                          xxxxxxxxxxxxx110xxxxx0111x100111
9579                                                          st3d.  */
9580                                                       return 1859;
9581                                                     }
9582                                                 }
9583                                             }
9584                                         }
9585                                       else
9586                                         {
9587                                           if (((word >> 31) & 0x1) == 0)
9588                                             {
9589                                               /* 33222222222211111111110000000000
9590                                                  10987654321098765432109876543210
9591                                                  xxxxxxxxxxxxx110xxxxx1xx1x100110
9592                                                  fnmls.  */
9593                                               return 1413;
9594                                             }
9595                                           else
9596                                             {
9597                                               if (((word >> 22) & 0x1) == 0)
9598                                                 {
9599                                                   if (((word >> 23) & 0x1) == 0)
9600                                                     {
9601                                                       /* 33222222222211111111110000000000
9602                                                          10987654321098765432109876543210
9603                                                          xxxxxxxxxxxxx110xxxxx1001x100111
9604                                                          st2w.  */
9605                                                       return 1855;
9606                                                     }
9607                                                   else
9608                                                     {
9609                                                       /* 33222222222211111111110000000000
9610                                                          10987654321098765432109876543210
9611                                                          xxxxxxxxxxxxx110xxxxx1011x100111
9612                                                          st2d.  */
9613                                                       return 1851;
9614                                                     }
9615                                                 }
9616                                               else
9617                                                 {
9618                                                   if (((word >> 23) & 0x1) == 0)
9619                                                     {
9620                                                       /* 33222222222211111111110000000000
9621                                                          10987654321098765432109876543210
9622                                                          xxxxxxxxxxxxx110xxxxx1101x100111
9623                                                          st4w.  */
9624                                                       return 1871;
9625                                                     }
9626                                                   else
9627                                                     {
9628                                                       /* 33222222222211111111110000000000
9629                                                          10987654321098765432109876543210
9630                                                          xxxxxxxxxxxxx110xxxxx1111x100111
9631                                                          st4d.  */
9632                                                       return 1867;
9633                                                     }
9634                                                 }
9635                                             }
9636                                         }
9637                                     }
9638                                 }
9639                             }
9640                         }
9641                       else
9642                         {
9643                           if (((word >> 21) & 0x1) == 0)
9644                             {
9645                               if (((word >> 30) & 0x1) == 0)
9646                                 {
9647                                   if (((word >> 14) & 0x1) == 0)
9648                                     {
9649                                       if (((word >> 13) & 0x1) == 0)
9650                                         {
9651                                           if (((word >> 4) & 0x1) == 0)
9652                                             {
9653                                               /* 33222222222211111111110000000000
9654                                                  10987654321098765432109876543210
9655                                                  xxxx0xxxxxxxx001xxxxx0xx1x10010x
9656                                                  cmpeq.  */
9657                                               return 1275;
9658                                             }
9659                                           else
9660                                             {
9661                                               /* 33222222222211111111110000000000
9662                                                  10987654321098765432109876543210
9663                                                  xxxx1xxxxxxxx001xxxxx0xx1x10010x
9664                                                  cmpne.  */
9665                                               return 1298;
9666                                             }
9667                                         }
9668                                       else
9669                                         {
9670                                           if (((word >> 20) & 0x1) == 0)
9671                                             {
9672                                               if (((word >> 22) & 0x1) == 0)
9673                                                 {
9674                                                   if (((word >> 23) & 0x1) == 0)
9675                                                     {
9676                                                       /* 33222222222211111111110000000000
9677                                                          10987654321098765432109876543210
9678                                                          xxxxxxxxxxxxx101xxxx00001x10010x
9679                                                          ld1sh.  */
9680                                                       return 1534;
9681                                                     }
9682                                                   else
9683                                                     {
9684                                                       /* 33222222222211111111110000000000
9685                                                          10987654321098765432109876543210
9686                                                          xxxxxxxxxxxxx101xxxx00011x10010x
9687                                                          ld1sb.  */
9688                                                       return 1521;
9689                                                     }
9690                                                 }
9691                                               else
9692                                                 {
9693                                                   if (((word >> 23) & 0x1) == 0)
9694                                                     {
9695                                                       /* 33222222222211111111110000000000
9696                                                          10987654321098765432109876543210
9697                                                          xxxxxxxxxxxxx101xxxx00101x10010x
9698                                                          ld1w.  */
9699                                                       return 1553;
9700                                                     }
9701                                                   else
9702                                                     {
9703                                                       /* 33222222222211111111110000000000
9704                                                          10987654321098765432109876543210
9705                                                          xxxxxxxxxxxxx101xxxx00111x10010x
9706                                                          ld1sb.  */
9707                                                       return 1523;
9708                                                     }
9709                                                 }
9710                                             }
9711                                           else
9712                                             {
9713                                               if (((word >> 22) & 0x1) == 0)
9714                                                 {
9715                                                   if (((word >> 23) & 0x1) == 0)
9716                                                     {
9717                                                       /* 33222222222211111111110000000000
9718                                                          10987654321098765432109876543210
9719                                                          xxxxxxxxxxxxx101xxxx10001x10010x
9720                                                          ldnf1sh.  */
9721                                                       return 1651;
9722                                                     }
9723                                                   else
9724                                                     {
9725                                                       /* 33222222222211111111110000000000
9726                                                          10987654321098765432109876543210
9727                                                          xxxxxxxxxxxxx101xxxx10011x10010x
9728                                                          ldnf1sb.  */
9729                                                       return 1648;
9730                                                     }
9731                                                 }
9732                                               else
9733                                                 {
9734                                                   if (((word >> 23) & 0x1) == 0)
9735                                                     {
9736                                                       /* 33222222222211111111110000000000
9737                                                          10987654321098765432109876543210
9738                                                          xxxxxxxxxxxxx101xxxx10101x10010x
9739                                                          ldnf1w.  */
9740                                                       return 1654;
9741                                                     }
9742                                                   else
9743                                                     {
9744                                                       /* 33222222222211111111110000000000
9745                                                          10987654321098765432109876543210
9746                                                          xxxxxxxxxxxxx101xxxx10111x10010x
9747                                                          ldnf1sb.  */
9748                                                       return 1650;
9749                                                     }
9750                                                 }
9751                                             }
9752                                         }
9753                                     }
9754                                   else
9755                                     {
9756                                       if (((word >> 31) & 0x1) == 0)
9757                                         {
9758                                           if (((word >> 4) & 0x1) == 0)
9759                                             {
9760                                               if (((word >> 20) & 0x1) == 0)
9761                                                 {
9762                                                   if (((word >> 22) & 0x1) == 0)
9763                                                     {
9764                                                       /* 33222222222211111111110000000000
9765                                                          10987654321098765432109876543210
9766                                                          xxxx0xxxxxxxxx11xxxx000x1x100100
9767                                                          brkpa.  */
9768                                                       return 1261;
9769                                                     }
9770                                                   else
9771                                                     {
9772                                                       /* 33222222222211111111110000000000
9773                                                          10987654321098765432109876543210
9774                                                          xxxx0xxxxxxxxx11xxxx001x1x100100
9775                                                          brkpas.  */
9776                                                       return 1262;
9777                                                     }
9778                                                 }
9779                                               else
9780                                                 {
9781                                                   if (((word >> 16) & 0x1) == 0)
9782                                                     {
9783                                                       if (((word >> 19) & 0x1) == 0)
9784                                                         {
9785                                                           /* 33222222222211111111110000000000
9786                                                              10987654321098765432109876543210
9787                                                              xxxx0xxxxxxxxx110xx010xx1x100100
9788                                                              ptest.  */
9789                                                           return 1731;
9790                                                         }
9791                                                       else
9792                                                         {
9793                                                           if (((word >> 10) & 0x1) == 0)
9794                                                             {
9795                                                               if (((word >> 12) & 0x1) == 0)
9796                                                                 {
9797                                                                   if (((word >> 13) & 0x1) == 0)
9798                                                                     {
9799                                                                       /* 33222222222211111111110000000000
9800                                                                          10987654321098765432109876543210
9801                                                                          xxxx0xxxxx0x00110xx110xx1x100100
9802                                                                          pfirst.  */
9803                                                                       return 1701;
9804                                                                     }
9805                                                                   else
9806                                                                     {
9807                                                                       /* 33222222222211111111110000000000
9808                                                                          10987654321098765432109876543210
9809                                                                          xxxx0xxxxx0x01110xx110xx1x100100
9810                                                                          ptrue.  */
9811                                                                       return 1732;
9812                                                                     }
9813                                                                 }
9814                                                               else
9815                                                                 {
9816                                                                   if (((word >> 22) & 0x1) == 0)
9817                                                                     {
9818                                                                       /* 33222222222211111111110000000000
9819                                                                          10987654321098765432109876543210
9820                                                                          xxxx0xxxxx0x1x110xx1100x1x100100
9821                                                                          rdffr.  */
9822                                                                       return 1738;
9823                                                                     }
9824                                                                   else
9825                                                                     {
9826                                                                       /* 33222222222211111111110000000000
9827                                                                          10987654321098765432109876543210
9828                                                                          xxxx0xxxxx0x1x110xx1101x1x100100
9829                                                                          rdffrs.  */
9830                                                                       return 1739;
9831                                                                     }
9832                                                                 }
9833                                                             }
9834                                                           else
9835                                                             {
9836                                                               /* 33222222222211111111110000000000
9837                                                                  10987654321098765432109876543210
9838                                                                  xxxx0xxxxx1xxx110xx110xx1x100100
9839                                                                  pfalse.  */
9840                                                               return 1700;
9841                                                             }
9842                                                         }
9843                                                     }
9844                                                   else
9845                                                     {
9846                                                       if (((word >> 10) & 0x1) == 0)
9847                                                         {
9848                                                           if (((word >> 12) & 0x1) == 0)
9849                                                             {
9850                                                               /* 33222222222211111111110000000000
9851                                                                  10987654321098765432109876543210
9852                                                                  xxxx0xxxxx0x0x111xxx10xx1x100100
9853                                                                  ptrues.  */
9854                                                               return 1733;
9855                                                             }
9856                                                           else
9857                                                             {
9858                                                               /* 33222222222211111111110000000000
9859                                                                  10987654321098765432109876543210
9860                                                                  xxxx0xxxxx0x1x111xxx10xx1x100100
9861                                                                  rdffr.  */
9862                                                               return 1737;
9863                                                             }
9864                                                         }
9865                                                       else
9866                                                         {
9867                                                           /* 33222222222211111111110000000000
9868                                                              10987654321098765432109876543210
9869                                                              xxxx0xxxxx1xxx111xxx10xx1x100100
9870                                                              pnext.  */
9871                                                           return 1702;
9872                                                         }
9873                                                     }
9874                                                 }
9875                                             }
9876                                           else
9877                                             {
9878                                               if (((word >> 22) & 0x1) == 0)
9879                                                 {
9880                                                   /* 33222222222211111111110000000000
9881                                                      10987654321098765432109876543210
9882                                                      xxxx1xxxxxxxxx11xxxxx00x1x100100
9883                                                      brkpb.  */
9884                                                   return 1263;
9885                                                 }
9886                                               else
9887                                                 {
9888                                                   /* 33222222222211111111110000000000
9889                                                      10987654321098765432109876543210
9890                                                      xxxx1xxxxxxxxx11xxxxx01x1x100100
9891                                                      brkpbs.  */
9892                                                   return 1264;
9893                                                 }
9894                                             }
9895                                         }
9896                                       else
9897                                         {
9898                                           if (((word >> 13) & 0x1) == 0)
9899                                             {
9900                                               if (((word >> 22) & 0x1) == 0)
9901                                                 {
9902                                                   if (((word >> 23) & 0x1) == 0)
9903                                                     {
9904                                                       /* 33222222222211111111110000000000
9905                                                          10987654321098765432109876543210
9906                                                          xxxxxxxxxxxxx011xxxxx0001x100101
9907                                                          ldnt1w.  */
9908                                                       return 1662;
9909                                                     }
9910                                                   else
9911                                                     {
9912                                                       /* 33222222222211111111110000000000
9913                                                          10987654321098765432109876543210
9914                                                          xxxxxxxxxxxxx011xxxxx0011x100101
9915                                                          ldnt1d.  */
9916                                                       return 1658;
9917                                                     }
9918                                                 }
9919                                               else
9920                                                 {
9921                                                   if (((word >> 23) & 0x1) == 0)
9922                                                     {
9923                                                       /* 33222222222211111111110000000000
9924                                                          10987654321098765432109876543210
9925                                                          xxxxxxxxxxxxx011xxxxx0101x100101
9926                                                          ld3w.  */
9927                                                       return 1570;
9928                                                     }
9929                                                   else
9930                                                     {
9931                                                       /* 33222222222211111111110000000000
9932                                                          10987654321098765432109876543210
9933                                                          xxxxxxxxxxxxx011xxxxx0111x100101
9934                                                          ld3d.  */
9935                                                       return 1566;
9936                                                     }
9937                                                 }
9938                                             }
9939                                           else
9940                                             {
9941                                               if (((word >> 22) & 0x1) == 0)
9942                                                 {
9943                                                   if (((word >> 23) & 0x1) == 0)
9944                                                     {
9945                                                       /* 33222222222211111111110000000000
9946                                                          10987654321098765432109876543210
9947                                                          xxxxxxxxxxxxx111xxxxx0001x100101
9948                                                          ldnt1w.  */
9949                                                       return 1663;
9950                                                     }
9951                                                   else
9952                                                     {
9953                                                       /* 33222222222211111111110000000000
9954                                                          10987654321098765432109876543210
9955                                                          xxxxxxxxxxxxx111xxxxx0011x100101
9956                                                          ldnt1d.  */
9957                                                       return 1659;
9958                                                     }
9959                                                 }
9960                                               else
9961                                                 {
9962                                                   if (((word >> 23) & 0x1) == 0)
9963                                                     {
9964                                                       /* 33222222222211111111110000000000
9965                                                          10987654321098765432109876543210
9966                                                          xxxxxxxxxxxxx111xxxxx0101x100101
9967                                                          ld3w.  */
9968                                                       return 1571;
9969                                                     }
9970                                                   else
9971                                                     {
9972                                                       /* 33222222222211111111110000000000
9973                                                          10987654321098765432109876543210
9974                                                          xxxxxxxxxxxxx111xxxxx0111x100101
9975                                                          ld3d.  */
9976                                                       return 1567;
9977                                                     }
9978                                                 }
9979                                             }
9980                                         }
9981                                     }
9982                                 }
9983                               else
9984                                 {
9985                                   if (((word >> 13) & 0x1) == 0)
9986                                     {
9987                                       if (((word >> 31) & 0x1) == 0)
9988                                         {
9989                                           if (((word >> 14) & 0x1) == 0)
9990                                             {
9991                                               if (((word >> 19) & 0x1) == 0)
9992                                                 {
9993                                                   if (((word >> 20) & 0x1) == 0)
9994                                                     {
9995                                                       if (((word >> 16) & 0x1) == 0)
9996                                                         {
9997                                                           if (((word >> 17) & 0x1) == 0)
9998                                                             {
9999                                                               if (((word >> 18) & 0x1) == 0)
10000                                                                 {
10001                                                                   /* 33222222222211111111110000000000
10002                                                                      10987654321098765432109876543210
10003                                                                      xxxxxxxxxxxxx001000000xx1x100110
10004                                                                      fadd.  */
10005                                                                   return 1337;
10006                                                                 }
10007                                                               else
10008                                                                 {
10009                                                                   /* 33222222222211111111110000000000
10010                                                                      10987654321098765432109876543210
10011                                                                      xxxxxxxxxxxxx001001000xx1x100110
10012                                                                      fmaxnm.  */
10013                                                                   return 1384;
10014                                                                 }
10015                                                             }
10016                                                           else
10017                                                             {
10018                                                               if (((word >> 18) & 0x1) == 0)
10019                                                                 {
10020                                                                   /* 33222222222211111111110000000000
10021                                                                      10987654321098765432109876543210
10022                                                                      xxxxxxxxxxxxx001010000xx1x100110
10023                                                                      fmul.  */
10024                                                                   return 1404;
10025                                                                 }
10026                                                               else
10027                                                                 {
10028                                                                   /* 33222222222211111111110000000000
10029                                                                      10987654321098765432109876543210
10030                                                                      xxxxxxxxxxxxx001011000xx1x100110
10031                                                                      fmax.  */
10032                                                                   return 1382;
10033                                                                 }
10034                                                             }
10035                                                         }
10036                                                       else
10037                                                         {
10038                                                           if (((word >> 17) & 0x1) == 0)
10039                                                             {
10040                                                               if (((word >> 18) & 0x1) == 0)
10041                                                                 {
10042                                                                   /* 33222222222211111111110000000000
10043                                                                      10987654321098765432109876543210
10044                                                                      xxxxxxxxxxxxx001100000xx1x100110
10045                                                                      fsub.  */
10046                                                                   return 1430;
10047                                                                 }
10048                                                               else
10049                                                                 {
10050                                                                   /* 33222222222211111111110000000000
10051                                                                      10987654321098765432109876543210
10052                                                                      xxxxxxxxxxxxx001101000xx1x100110
10053                                                                      fminnm.  */
10054                                                                   return 1390;
10055                                                                 }
10056                                                             }
10057                                                           else
10058                                                             {
10059                                                               if (((word >> 18) & 0x1) == 0)
10060                                                                 {
10061                                                                   /* 33222222222211111111110000000000
10062                                                                      10987654321098765432109876543210
10063                                                                      xxxxxxxxxxxxx001110000xx1x100110
10064                                                                      fsubr.  */
10065                                                                   return 1432;
10066                                                                 }
10067                                                               else
10068                                                                 {
10069                                                                   /* 33222222222211111111110000000000
10070                                                                      10987654321098765432109876543210
10071                                                                      xxxxxxxxxxxxx001111000xx1x100110
10072                                                                      fmin.  */
10073                                                                   return 1388;
10074                                                                 }
10075                                                             }
10076                                                         }
10077                                                     }
10078                                                   else
10079                                                     {
10080                                                       /* 33222222222211111111110000000000
10081                                                          10987654321098765432109876543210
10082                                                          xxxxxxxxxxxxx001xxx010xx1x100110
10083                                                          ftmad.  */
10084                                                       return 1434;
10085                                                     }
10086                                                 }
10087                                               else
10088                                                 {
10089                                                   if (((word >> 16) & 0x1) == 0)
10090                                                     {
10091                                                       if (((word >> 17) & 0x1) == 0)
10092                                                         {
10093                                                           if (((word >> 18) & 0x1) == 0)
10094                                                             {
10095                                                               if (((word >> 20) & 0x1) == 0)
10096                                                                 {
10097                                                                   /* 33222222222211111111110000000000
10098                                                                      10987654321098765432109876543210
10099                                                                      xxxxxxxxxxxxx001000100xx1x100110
10100                                                                      fabd.  */
10101                                                                   return 1332;
10102                                                                 }
10103                                                               else
10104                                                                 {
10105                                                                   /* 33222222222211111111110000000000
10106                                                                      10987654321098765432109876543210
10107                                                                      xxxxxxxxxxxxx001000110xx1x100110
10108                                                                      fadd.  */
10109                                                                   return 1338;
10110                                                                 }
10111                                                             }
10112                                                           else
10113                                                             {
10114                                                               if (((word >> 20) & 0x1) == 0)
10115                                                                 {
10116                                                                   /* 33222222222211111111110000000000
10117                                                                      10987654321098765432109876543210
10118                                                                      xxxxxxxxxxxxx001001100xx1x100110
10119                                                                      fdivr.  */
10120                                                                   return 1378;
10121                                                                 }
10122                                                               else
10123                                                                 {
10124                                                                   /* 33222222222211111111110000000000
10125                                                                      10987654321098765432109876543210
10126                                                                      xxxxxxxxxxxxx001001110xx1x100110
10127                                                                      fmaxnm.  */
10128                                                                   return 1385;
10129                                                                 }
10130                                                             }
10131                                                         }
10132                                                       else
10133                                                         {
10134                                                           if (((word >> 18) & 0x1) == 0)
10135                                                             {
10136                                                               if (((word >> 20) & 0x1) == 0)
10137                                                                 {
10138                                                                   /* 33222222222211111111110000000000
10139                                                                      10987654321098765432109876543210
10140                                                                      xxxxxxxxxxxxx001010100xx1x100110
10141                                                                      fmulx.  */
10142                                                                   return 1409;
10143                                                                 }
10144                                                               else
10145                                                                 {
10146                                                                   /* 33222222222211111111110000000000
10147                                                                      10987654321098765432109876543210
10148                                                                      xxxxxxxxxxxxx001010110xx1x100110
10149                                                                      fmul.  */
10150                                                                   return 1405;
10151                                                                 }
10152                                                             }
10153                                                           else
10154                                                             {
10155                                                               /* 33222222222211111111110000000000
10156                                                                  10987654321098765432109876543210
10157                                                                  xxxxxxxxxxxxx0010111x0xx1x100110
10158                                                                  fmax.  */
10159                                                               return 1383;
10160                                                             }
10161                                                         }
10162                                                     }
10163                                                   else
10164                                                     {
10165                                                       if (((word >> 17) & 0x1) == 0)
10166                                                         {
10167                                                           if (((word >> 18) & 0x1) == 0)
10168                                                             {
10169                                                               if (((word >> 20) & 0x1) == 0)
10170                                                                 {
10171                                                                   /* 33222222222211111111110000000000
10172                                                                      10987654321098765432109876543210
10173                                                                      xxxxxxxxxxxxx001100100xx1x100110
10174                                                                      fscale.  */
10175                                                                   return 1427;
10176                                                                 }
10177                                                               else
10178                                                                 {
10179                                                                   /* 33222222222211111111110000000000
10180                                                                      10987654321098765432109876543210
10181                                                                      xxxxxxxxxxxxx001100110xx1x100110
10182                                                                      fsub.  */
10183                                                                   return 1431;
10184                                                                 }
10185                                                             }
10186                                                           else
10187                                                             {
10188                                                               if (((word >> 20) & 0x1) == 0)
10189                                                                 {
10190                                                                   /* 33222222222211111111110000000000
10191                                                                      10987654321098765432109876543210
10192                                                                      xxxxxxxxxxxxx001101100xx1x100110
10193                                                                      fdiv.  */
10194                                                                   return 1377;
10195                                                                 }
10196                                                               else
10197                                                                 {
10198                                                                   /* 33222222222211111111110000000000
10199                                                                      10987654321098765432109876543210
10200                                                                      xxxxxxxxxxxxx001101110xx1x100110
10201                                                                      fminnm.  */
10202                                                                   return 1391;
10203                                                                 }
10204                                                             }
10205                                                         }
10206                                                       else
10207                                                         {
10208                                                           if (((word >> 18) & 0x1) == 0)
10209                                                             {
10210                                                               /* 33222222222211111111110000000000
10211                                                                  10987654321098765432109876543210
10212                                                                  xxxxxxxxxxxxx0011101x0xx1x100110
10213                                                                  fsubr.  */
10214                                                               return 1433;
10215                                                             }
10216                                                           else
10217                                                             {
10218                                                               /* 33222222222211111111110000000000
10219                                                                  10987654321098765432109876543210
10220                                                                  xxxxxxxxxxxxx0011111x0xx1x100110
10221                                                                  fmin.  */
10222                                                               return 1389;
10223                                                             }
10224                                                         }
10225                                                     }
10226                                                 }
10227                                             }
10228                                           else
10229                                             {
10230                                               if (((word >> 4) & 0x1) == 0)
10231                                                 {
10232                                                   /* 33222222222211111111110000000000
10233                                                      10987654321098765432109876543210
10234                                                      xxxx0xxxxxxxx011xxxxx0xx1x100110
10235                                                      fcmuo.  */
10236                                                   return 1355;
10237                                                 }
10238                                               else
10239                                                 {
10240                                                   /* 33222222222211111111110000000000
10241                                                      10987654321098765432109876543210
10242                                                      xxxx1xxxxxxxx011xxxxx0xx1x100110
10243                                                      facge.  */
10244                                                   return 1334;
10245                                                 }
10246                                             }
10247                                         }
10248                                       else
10249                                         {
10250                                           if (((word >> 22) & 0x1) == 0)
10251                                             {
10252                                               if (((word >> 23) & 0x1) == 0)
10253                                                 {
10254                                                   /* 33222222222211111111110000000000
10255                                                      10987654321098765432109876543210
10256                                                      xxxxxxxxxxxxx0x1xxxxx0001x100111
10257                                                      st1w.  */
10258                                                   return 1837;
10259                                                 }
10260                                               else
10261                                                 {
10262                                                   /* 33222222222211111111110000000000
10263                                                      10987654321098765432109876543210
10264                                                      xxxxxxxxxxxxx0x1xxxxx0011x100111
10265                                                      st1d.  */
10266                                                   return 1816;
10267                                                 }
10268                                             }
10269                                           else
10270                                             {
10271                                               /* 33222222222211111111110000000000
10272                                                  10987654321098765432109876543210
10273                                                  xxxxxxxxxxxxx0x1xxxxx01x1x100111
10274                                                  st1w.  */
10275                                               return 1842;
10276                                             }
10277                                         }
10278                                     }
10279                                   else
10280                                     {
10281                                       if (((word >> 14) & 0x1) == 0)
10282                                         {
10283                                           if (((word >> 31) & 0x1) == 0)
10284                                             {
10285                                               if (((word >> 16) & 0x1) == 0)
10286                                                 {
10287                                                   if (((word >> 17) & 0x1) == 0)
10288                                                     {
10289                                                       if (((word >> 18) & 0x1) == 0)
10290                                                         {
10291                                                           if (((word >> 19) & 0x1) == 0)
10292                                                             {
10293                                                               if (((word >> 20) & 0x1) == 0)
10294                                                                 {
10295                                                                   /* 33222222222211111111110000000000
10296                                                                      10987654321098765432109876543210
10297                                                                      xxxxxxxxxxxxx101000000xx1x100110
10298                                                                      frintn.  */
10299                                                                   return 1421;
10300                                                                 }
10301                                                               else
10302                                                                 {
10303                                                                   /* 33222222222211111111110000000000
10304                                                                      10987654321098765432109876543210
10305                                                                      xxxxxxxxxxxxx101000010xx1x100110
10306                                                                      scvtf.  */
10307                                                                   return 1751;
10308                                                                 }
10309                                                             }
10310                                                           else
10311                                                             {
10312                                                               if (((word >> 20) & 0x1) == 0)
10313                                                                 {
10314                                                                   if (((word >> 22) & 0x1) == 0)
10315                                                                     {
10316                                                                       /* 33222222222211111111110000000000
10317                                                                          10987654321098765432109876543210
10318                                                                          xxxxxxxxxxxxx1010001000x1x100110
10319                                                                          fcvt.  */
10320                                                                       return 1357;
10321                                                                     }
10322                                                                   else
10323                                                                     {
10324                                                                       /* 33222222222211111111110000000000
10325                                                                          10987654321098765432109876543210
10326                                                                          xxxxxxxxxxxxx1010001001x1x100110
10327                                                                          fcvt.  */
10328                                                                       return 1359;
10329                                                                     }
10330                                                                 }
10331                                                               else
10332                                                                 {
10333                                                                   /* 33222222222211111111110000000000
10334                                                                      10987654321098765432109876543210
10335                                                                      xxxxxxxxxxxxx101000110xx1x100110
10336                                                                      fcvtzs.  */
10337                                                                   return 1367;
10338                                                                 }
10339                                                             }
10340                                                         }
10341                                                       else
10342                                                         {
10343                                                           if (((word >> 19) & 0x1) == 0)
10344                                                             {
10345                                                               if (((word >> 20) & 0x1) == 0)
10346                                                                 {
10347                                                                   /* 33222222222211111111110000000000
10348                                                                      10987654321098765432109876543210
10349                                                                      xxxxxxxxxxxxx101001000xx1x100110
10350                                                                      frinta.  */
10351                                                                   return 1418;
10352                                                                 }
10353                                                               else
10354                                                                 {
10355                                                                   if (((word >> 22) & 0x1) == 0)
10356                                                                     {
10357                                                                       /* 33222222222211111111110000000000
10358                                                                          10987654321098765432109876543210
10359                                                                          xxxxxxxxxxxxx1010010100x1x100110
10360                                                                          scvtf.  */
10361                                                                       return 1750;
10362                                                                     }
10363                                                                   else
10364                                                                     {
10365                                                                       if (((word >> 23) & 0x1) == 0)
10366                                                                         {
10367                                                                           /* 33222222222211111111110000000000
10368                                                                              10987654321098765432109876543210
10369                                                                              xxxxxxxxxxxxx101001010101x100110
10370                                                                              scvtf.  */
10371                                                                           return 1749;
10372                                                                         }
10373                                                                       else
10374                                                                         {
10375                                                                           /* 33222222222211111111110000000000
10376                                                                              10987654321098765432109876543210
10377                                                                              xxxxxxxxxxxxx101001010111x100110
10378                                                                              scvtf.  */
10379                                                                           return 1753;
10380                                                                         }
10381                                                                     }
10382                                                                 }
10383                                                             }
10384                                                           else
10385                                                             {
10386                                                               if (((word >> 20) & 0x1) == 0)
10387                                                                 {
10388                                                                   /* 33222222222211111111110000000000
10389                                                                      10987654321098765432109876543210
10390                                                                      xxxxxxxxxxxxx101001100xx1x100110
10391                                                                      frecpx.  */
10392                                                                   return 1417;
10393                                                                 }
10394                                                               else
10395                                                                 {
10396                                                                   if (((word >> 22) & 0x1) == 0)
10397                                                                     {
10398                                                                       /* 33222222222211111111110000000000
10399                                                                          10987654321098765432109876543210
10400                                                                          xxxxxxxxxxxxx1010011100x1x100110
10401                                                                          fcvtzs.  */
10402                                                                       return 1366;
10403                                                                     }
10404                                                                   else
10405                                                                     {
10406                                                                       if (((word >> 23) & 0x1) == 0)
10407                                                                         {
10408                                                                           /* 33222222222211111111110000000000
10409                                                                              10987654321098765432109876543210
10410                                                                              xxxxxxxxxxxxx101001110101x100110
10411                                                                              fcvtzs.  */
10412                                                                           return 1364;
10413                                                                         }
10414                                                                       else
10415                                                                         {
10416                                                                           /* 33222222222211111111110000000000
10417                                                                              10987654321098765432109876543210
10418                                                                              xxxxxxxxxxxxx101001110111x100110
10419                                                                              fcvtzs.  */
10420                                                                           return 1368;
10421                                                                         }
10422                                                                     }
10423                                                                 }
10424                                                             }
10425                                                         }
10426                                                     }
10427                                                   else
10428                                                     {
10429                                                       if (((word >> 18) & 0x1) == 0)
10430                                                         {
10431                                                           if (((word >> 19) & 0x1) == 0)
10432                                                             {
10433                                                               if (((word >> 20) & 0x1) == 0)
10434                                                                 {
10435                                                                   /* 33222222222211111111110000000000
10436                                                                      10987654321098765432109876543210
10437                                                                      xxxxxxxxxxxxx101010000xx1x100110
10438                                                                      frintm.  */
10439                                                                   return 1420;
10440                                                                 }
10441                                                               else
10442                                                                 {
10443                                                                   /* 33222222222211111111110000000000
10444                                                                      10987654321098765432109876543210
10445                                                                      xxxxxxxxxxxxx101010010xx1x100110
10446                                                                      scvtf.  */
10447                                                                   return 1748;
10448                                                                 }
10449                                                             }
10450                                                           else
10451                                                             {
10452                                                               if (((word >> 20) & 0x1) == 0)
10453                                                                 {
10454                                                                   /* 33222222222211111111110000000000
10455                                                                      10987654321098765432109876543210
10456                                                                      xxxxxxxxxxxxx101010100xx1x100110
10457                                                                      fcvt.  */
10458                                                                   return 1361;
10459                                                                 }
10460                                                               else
10461                                                                 {
10462                                                                   /* 33222222222211111111110000000000
10463                                                                      10987654321098765432109876543210
10464                                                                      xxxxxxxxxxxxx101010110xx1x100110
10465                                                                      fcvtzs.  */
10466                                                                   return 1363;
10467                                                                 }
10468                                                             }
10469                                                         }
10470                                                       else
10471                                                         {
10472                                                           if (((word >> 19) & 0x1) == 0)
10473                                                             {
10474                                                               if (((word >> 20) & 0x1) == 0)
10475                                                                 {
10476                                                                   /* 33222222222211111111110000000000
10477                                                                      10987654321098765432109876543210
10478                                                                      xxxxxxxxxxxxx101011000xx1x100110
10479                                                                      frintx.  */
10480                                                                   return 1423;
10481                                                                 }
10482                                                               else
10483                                                                 {
10484                                                                   if (((word >> 23) & 0x1) == 0)
10485                                                                     {
10486                                                                       /* 33222222222211111111110000000000
10487                                                                          10987654321098765432109876543210
10488                                                                          xxxxxxxxxxxxx101011010x01x100110
10489                                                                          scvtf.  */
10490                                                                       return 1752;
10491                                                                     }
10492                                                                   else
10493                                                                     {
10494                                                                       /* 33222222222211111111110000000000
10495                                                                          10987654321098765432109876543210
10496                                                                          xxxxxxxxxxxxx101011010x11x100110
10497                                                                          scvtf.  */
10498                                                                       return 1754;
10499                                                                     }
10500                                                                 }
10501                                                             }
10502                                                           else
10503                                                             {
10504                                                               if (((word >> 23) & 0x1) == 0)
10505                                                                 {
10506                                                                   /* 33222222222211111111110000000000
10507                                                                      10987654321098765432109876543210
10508                                                                      xxxxxxxxxxxxx1010111x0x01x100110
10509                                                                      fcvtzs.  */
10510                                                                   return 1365;
10511                                                                 }
10512                                                               else
10513                                                                 {
10514                                                                   /* 33222222222211111111110000000000
10515                                                                      10987654321098765432109876543210
10516                                                                      xxxxxxxxxxxxx1010111x0x11x100110
10517                                                                      fcvtzs.  */
10518                                                                   return 1369;
10519                                                                 }
10520                                                             }
10521                                                         }
10522                                                     }
10523                                                 }
10524                                               else
10525                                                 {
10526                                                   if (((word >> 17) & 0x1) == 0)
10527                                                     {
10528                                                       if (((word >> 18) & 0x1) == 0)
10529                                                         {
10530                                                           if (((word >> 19) & 0x1) == 0)
10531                                                             {
10532                                                               if (((word >> 20) & 0x1) == 0)
10533                                                                 {
10534                                                                   /* 33222222222211111111110000000000
10535                                                                      10987654321098765432109876543210
10536                                                                      xxxxxxxxxxxxx101100000xx1x100110
10537                                                                      frintp.  */
10538                                                                   return 1422;
10539                                                                 }
10540                                                               else
10541                                                                 {
10542                                                                   /* 33222222222211111111110000000000
10543                                                                      10987654321098765432109876543210
10544                                                                      xxxxxxxxxxxxx101100010xx1x100110
10545                                                                      ucvtf.  */
10546                                                                   return 1903;
10547                                                                 }
10548                                                             }
10549                                                           else
10550                                                             {
10551                                                               if (((word >> 20) & 0x1) == 0)
10552                                                                 {
10553                                                                   if (((word >> 22) & 0x1) == 0)
10554                                                                     {
10555                                                                       /* 33222222222211111111110000000000
10556                                                                          10987654321098765432109876543210
10557                                                                          xxxxxxxxxxxxx1011001000x1x100110
10558                                                                          fcvt.  */
10559                                                                       return 1358;
10560                                                                     }
10561                                                                   else
10562                                                                     {
10563                                                                       /* 33222222222211111111110000000000
10564                                                                          10987654321098765432109876543210
10565                                                                          xxxxxxxxxxxxx1011001001x1x100110
10566                                                                          fcvt.  */
10567                                                                       return 1360;
10568                                                                     }
10569                                                                 }
10570                                                               else
10571                                                                 {
10572                                                                   /* 33222222222211111111110000000000
10573                                                                      10987654321098765432109876543210
10574                                                                      xxxxxxxxxxxxx101100110xx1x100110
10575                                                                      fcvtzu.  */
10576                                                                   return 1374;
10577                                                                 }
10578                                                             }
10579                                                         }
10580                                                       else
10581                                                         {
10582                                                           if (((word >> 19) & 0x1) == 0)
10583                                                             {
10584                                                               if (((word >> 22) & 0x1) == 0)
10585                                                                 {
10586                                                                   /* 33222222222211111111110000000000
10587                                                                      10987654321098765432109876543210
10588                                                                      xxxxxxxxxxxxx1011010x00x1x100110
10589                                                                      ucvtf.  */
10590                                                                   return 1902;
10591                                                                 }
10592                                                               else
10593                                                                 {
10594                                                                   if (((word >> 23) & 0x1) == 0)
10595                                                                     {
10596                                                                       /* 33222222222211111111110000000000
10597                                                                          10987654321098765432109876543210
10598                                                                          xxxxxxxxxxxxx1011010x0101x100110
10599                                                                          ucvtf.  */
10600                                                                       return 1901;
10601                                                                     }
10602                                                                   else
10603                                                                     {
10604                                                                       /* 33222222222211111111110000000000
10605                                                                          10987654321098765432109876543210
10606                                                                          xxxxxxxxxxxxx1011010x0111x100110
10607                                                                          ucvtf.  */
10608                                                                       return 1905;
10609                                                                     }
10610                                                                 }
10611                                                             }
10612                                                           else
10613                                                             {
10614                                                               if (((word >> 20) & 0x1) == 0)
10615                                                                 {
10616                                                                   /* 33222222222211111111110000000000
10617                                                                      10987654321098765432109876543210
10618                                                                      xxxxxxxxxxxxx101101100xx1x100110
10619                                                                      fsqrt.  */
10620                                                                   return 1428;
10621                                                                 }
10622                                                               else
10623                                                                 {
10624                                                                   if (((word >> 22) & 0x1) == 0)
10625                                                                     {
10626                                                                       /* 33222222222211111111110000000000
10627                                                                          10987654321098765432109876543210
10628                                                                          xxxxxxxxxxxxx1011011100x1x100110
10629                                                                          fcvtzu.  */
10630                                                                       return 1373;
10631                                                                     }
10632                                                                   else
10633                                                                     {
10634                                                                       if (((word >> 23) & 0x1) == 0)
10635                                                                         {
10636                                                                           /* 33222222222211111111110000000000
10637                                                                              10987654321098765432109876543210
10638                                                                              xxxxxxxxxxxxx101101110101x100110
10639                                                                              fcvtzu.  */
10640                                                                           return 1371;
10641                                                                         }
10642                                                                       else
10643                                                                         {
10644                                                                           /* 33222222222211111111110000000000
10645                                                                              10987654321098765432109876543210
10646                                                                              xxxxxxxxxxxxx101101110111x100110
10647                                                                              fcvtzu.  */
10648                                                                           return 1375;
10649                                                                         }
10650                                                                     }
10651                                                                 }
10652                                                             }
10653                                                         }
10654                                                     }
10655                                                   else
10656                                                     {
10657                                                       if (((word >> 18) & 0x1) == 0)
10658                                                         {
10659                                                           if (((word >> 19) & 0x1) == 0)
10660                                                             {
10661                                                               if (((word >> 20) & 0x1) == 0)
10662                                                                 {
10663                                                                   /* 33222222222211111111110000000000
10664                                                                      10987654321098765432109876543210
10665                                                                      xxxxxxxxxxxxx101110000xx1x100110
10666                                                                      frintz.  */
10667                                                                   return 1424;
10668                                                                 }
10669                                                               else
10670                                                                 {
10671                                                                   /* 33222222222211111111110000000000
10672                                                                      10987654321098765432109876543210
10673                                                                      xxxxxxxxxxxxx101110010xx1x100110
10674                                                                      ucvtf.  */
10675                                                                   return 1900;
10676                                                                 }
10677                                                             }
10678                                                           else
10679                                                             {
10680                                                               if (((word >> 20) & 0x1) == 0)
10681                                                                 {
10682                                                                   /* 33222222222211111111110000000000
10683                                                                      10987654321098765432109876543210
10684                                                                      xxxxxxxxxxxxx101110100xx1x100110
10685                                                                      fcvt.  */
10686                                                                   return 1362;
10687                                                                 }
10688                                                               else
10689                                                                 {
10690                                                                   /* 33222222222211111111110000000000
10691                                                                      10987654321098765432109876543210
10692                                                                      xxxxxxxxxxxxx101110110xx1x100110
10693                                                                      fcvtzu.  */
10694                                                                   return 1370;
10695                                                                 }
10696                                                             }
10697                                                         }
10698                                                       else
10699                                                         {
10700                                                           if (((word >> 19) & 0x1) == 0)
10701                                                             {
10702                                                               if (((word >> 20) & 0x1) == 0)
10703                                                                 {
10704                                                                   /* 33222222222211111111110000000000
10705                                                                      10987654321098765432109876543210
10706                                                                      xxxxxxxxxxxxx101111000xx1x100110
10707                                                                      frinti.  */
10708                                                                   return 1419;
10709                                                                 }
10710                                                               else
10711                                                                 {
10712                                                                   if (((word >> 23) & 0x1) == 0)
10713                                                                     {
10714                                                                       /* 33222222222211111111110000000000
10715                                                                          10987654321098765432109876543210
10716                                                                          xxxxxxxxxxxxx101111010x01x100110
10717                                                                          ucvtf.  */
10718                                                                       return 1904;
10719                                                                     }
10720                                                                   else
10721                                                                     {
10722                                                                       /* 33222222222211111111110000000000
10723                                                                          10987654321098765432109876543210
10724                                                                          xxxxxxxxxxxxx101111010x11x100110
10725                                                                          ucvtf.  */
10726                                                                       return 1906;
10727                                                                     }
10728                                                                 }
10729                                                             }
10730                                                           else
10731                                                             {
10732                                                               if (((word >> 23) & 0x1) == 0)
10733                                                                 {
10734                                                                   /* 33222222222211111111110000000000
10735                                                                      10987654321098765432109876543210
10736                                                                      xxxxxxxxxxxxx1011111x0x01x100110
10737                                                                      fcvtzu.  */
10738                                                                   return 1372;
10739                                                                 }
10740                                                               else
10741                                                                 {
10742                                                                   /* 33222222222211111111110000000000
10743                                                                      10987654321098765432109876543210
10744                                                                      xxxxxxxxxxxxx1011111x0x11x100110
10745                                                                      fcvtzu.  */
10746                                                                   return 1376;
10747                                                                 }
10748                                                             }
10749                                                         }
10750                                                     }
10751                                                 }
10752                                             }
10753                                           else
10754                                             {
10755                                               if (((word >> 22) & 0x1) == 0)
10756                                                 {
10757                                                   if (((word >> 23) & 0x1) == 0)
10758                                                     {
10759                                                       /* 33222222222211111111110000000000
10760                                                          10987654321098765432109876543210
10761                                                          xxxxxxxxxxxxx101xxxxx0001x100111
10762                                                          st1w.  */
10763                                                       return 1838;
10764                                                     }
10765                                                   else
10766                                                     {
10767                                                       /* 33222222222211111111110000000000
10768                                                          10987654321098765432109876543210
10769                                                          xxxxxxxxxxxxx101xxxxx0011x100111
10770                                                          st1d.  */
10771                                                       return 1817;
10772                                                     }
10773                                                 }
10774                                               else
10775                                                 {
10776                                                   if (((word >> 23) & 0x1) == 0)
10777                                                     {
10778                                                       /* 33222222222211111111110000000000
10779                                                          10987654321098765432109876543210
10780                                                          xxxxxxxxxxxxx101xxxxx0101x100111
10781                                                          st1w.  */
10782                                                       return 1845;
10783                                                     }
10784                                                   else
10785                                                     {
10786                                                       /* 33222222222211111111110000000000
10787                                                          10987654321098765432109876543210
10788                                                          xxxxxxxxxxxxx101xxxxx0111x100111
10789                                                          st1d.  */
10790                                                       return 1821;
10791                                                     }
10792                                                 }
10793                                             }
10794                                         }
10795                                       else
10796                                         {
10797                                           if (((word >> 31) & 0x1) == 0)
10798                                             {
10799                                               /* 33222222222211111111110000000000
10800                                                  10987654321098765432109876543210
10801                                                  xxxxxxxxxxxxx111xxxxx0xx1x100110
10802                                                  facgt.  */
10803                                               return 1335;
10804                                             }
10805                                           else
10806                                             {
10807                                               if (((word >> 20) & 0x1) == 0)
10808                                                 {
10809                                                   /* 33222222222211111111110000000000
10810                                                      10987654321098765432109876543210
10811                                                      xxxxxxxxxxxxx111xxxx00xx1x100111
10812                                                      st1w.  */
10813                                                   return 1846;
10814                                                 }
10815                                               else
10816                                                 {
10817                                                   if (((word >> 22) & 0x1) == 0)
10818                                                     {
10819                                                       if (((word >> 23) & 0x1) == 0)
10820                                                         {
10821                                                           /* 33222222222211111111110000000000
10822                                                              10987654321098765432109876543210
10823                                                              xxxxxxxxxxxxx111xxxx10001x100111
10824                                                              stnt1w.  */
10825                                                           return 1880;
10826                                                         }
10827                                                       else
10828                                                         {
10829                                                           /* 33222222222211111111110000000000
10830                                                              10987654321098765432109876543210
10831                                                              xxxxxxxxxxxxx111xxxx10011x100111
10832                                                              stnt1d.  */
10833                                                           return 1876;
10834                                                         }
10835                                                     }
10836                                                   else
10837                                                     {
10838                                                       if (((word >> 23) & 0x1) == 0)
10839                                                         {
10840                                                           /* 33222222222211111111110000000000
10841                                                              10987654321098765432109876543210
10842                                                              xxxxxxxxxxxxx111xxxx10101x100111
10843                                                              st3w.  */
10844                                                           return 1864;
10845                                                         }
10846                                                       else
10847                                                         {
10848                                                           /* 33222222222211111111110000000000
10849                                                              10987654321098765432109876543210
10850                                                              xxxxxxxxxxxxx111xxxx10111x100111
10851                                                              st3d.  */
10852                                                           return 1860;
10853                                                         }
10854                                                     }
10855                                                 }
10856                                             }
10857                                         }
10858                                     }
10859                                 }
10860                             }
10861                           else
10862                             {
10863                               if (((word >> 30) & 0x1) == 0)
10864                                 {
10865                                   if (((word >> 14) & 0x1) == 0)
10866                                     {
10867                                       if (((word >> 20) & 0x1) == 0)
10868                                         {
10869                                           if (((word >> 31) & 0x1) == 0)
10870                                             {
10871                                               if (((word >> 16) & 0x1) == 0)
10872                                                 {
10873                                                   if (((word >> 17) & 0x1) == 0)
10874                                                     {
10875                                                       if (((word >> 18) & 0x1) == 0)
10876                                                         {
10877                                                           if (((word >> 19) & 0x1) == 0)
10878                                                             {
10879                                                               /* 33222222222211111111110000000000
10880                                                                  10987654321098765432109876543210
10881                                                                  xxxxxxxxxxxxxx01000001xx1x100100
10882                                                                  cntp.  */
10883                                                               return 1304;
10884                                                             }
10885                                                           else
10886                                                             {
10887                                                               if (((word >> 10) & 0x1) == 0)
10888                                                                 {
10889                                                                   if (((word >> 11) & 0x1) == 0)
10890                                                                     {
10891                                                                       if (((word >> 12) & 0x1) == 0)
10892                                                                         {
10893                                                                           /* 33222222222211111111110000000000
10894                                                                              10987654321098765432109876543210
10895                                                                              xxxxxxxxxx000x01000101xx1x100100
10896                                                                              sqincp.  */
10897                                                                           return 1795;
10898                                                                         }
10899                                                                       else
10900                                                                         {
10901                                                                           /* 33222222222211111111110000000000
10902                                                                              10987654321098765432109876543210
10903                                                                              xxxxxxxxxx001x01000101xx1x100100
10904                                                                              wrffr.  */
10905                                                                           return 1968;
10906                                                                         }
10907                                                                     }
10908                                                                   else
10909                                                                     {
10910                                                                       /* 33222222222211111111110000000000
10911                                                                          10987654321098765432109876543210
10912                                                                          xxxxxxxxxx01xx01000101xx1x100100
10913                                                                          sqincp.  */
10914                                                                       return 1797;
10915                                                                     }
10916                                                                 }
10917                                                               else
10918                                                                 {
10919                                                                   /* 33222222222211111111110000000000
10920                                                                      10987654321098765432109876543210
10921                                                                      xxxxxxxxxx1xxx01000101xx1x100100
10922                                                                      sqincp.  */
10923                                                                   return 1796;
10924                                                                 }
10925                                                             }
10926                                                         }
10927                                                       else
10928                                                         {
10929                                                           if (((word >> 11) & 0x1) == 0)
10930                                                             {
10931                                                               if (((word >> 12) & 0x1) == 0)
10932                                                                 {
10933                                                                   /* 33222222222211111111110000000000
10934                                                                      10987654321098765432109876543210
10935                                                                      xxxxxxxxxxx00x01001x01xx1x100100
10936                                                                      incp.  */
10937                                                                   return 1442;
10938                                                                 }
10939                                                               else
10940                                                                 {
10941                                                                   /* 33222222222211111111110000000000
10942                                                                      10987654321098765432109876543210
10943                                                                      xxxxxxxxxxx01x01001x01xx1x100100
10944                                                                      setffr.  */
10945                                                                   return 1762;
10946                                                                 }
10947                                                             }
10948                                                           else
10949                                                             {
10950                                                               /* 33222222222211111111110000000000
10951                                                                  10987654321098765432109876543210
10952                                                                  xxxxxxxxxxx1xx01001x01xx1x100100
10953                                                                  incp.  */
10954                                                               return 1443;
10955                                                             }
10956                                                         }
10957                                                     }
10958                                                   else
10959                                                     {
10960                                                       if (((word >> 10) & 0x1) == 0)
10961                                                         {
10962                                                           if (((word >> 11) & 0x1) == 0)
10963                                                             {
10964                                                               /* 33222222222211111111110000000000
10965                                                                  10987654321098765432109876543210
10966                                                                  xxxxxxxxxx00xx0101xx01xx1x100100
10967                                                                  sqdecp.  */
10968                                                               return 1781;
10969                                                             }
10970                                                           else
10971                                                             {
10972                                                               /* 33222222222211111111110000000000
10973                                                                  10987654321098765432109876543210
10974                                                                  xxxxxxxxxx01xx0101xx01xx1x100100
10975                                                                  sqdecp.  */
10976                                                               return 1783;
10977                                                             }
10978                                                         }
10979                                                       else
10980                                                         {
10981                                                           /* 33222222222211111111110000000000
10982                                                              10987654321098765432109876543210
10983                                                              xxxxxxxxxx1xxx0101xx01xx1x100100
10984                                                              sqdecp.  */
10985                                                           return 1782;
10986                                                         }
10987                                                     }
10988                                                 }
10989                                               else
10990                                                 {
10991                                                   if (((word >> 10) & 0x1) == 0)
10992                                                     {
10993                                                       if (((word >> 11) & 0x1) == 0)
10994                                                         {
10995                                                           if (((word >> 17) & 0x1) == 0)
10996                                                             {
10997                                                               if (((word >> 18) & 0x1) == 0)
10998                                                                 {
10999                                                                   /* 33222222222211111111110000000000
11000                                                                      10987654321098765432109876543210
11001                                                                      xxxxxxxxxx00xx01100x01xx1x100100
11002                                                                      uqincp.  */
11003                                                                   return 1943;
11004                                                                 }
11005                                                               else
11006                                                                 {
11007                                                                   /* 33222222222211111111110000000000
11008                                                                      10987654321098765432109876543210
11009                                                                      xxxxxxxxxx00xx01101x01xx1x100100
11010                                                                      decp.  */
11011                                                                   return 1317;
11012                                                                 }
11013                                                             }
11014                                                           else
11015                                                             {
11016                                                               /* 33222222222211111111110000000000
11017                                                                  10987654321098765432109876543210
11018                                                                  xxxxxxxxxx00xx0111xx01xx1x100100
11019                                                                  uqdecp.  */
11020                                                               return 1929;
11021                                                             }
11022                                                         }
11023                                                       else
11024                                                         {
11025                                                           if (((word >> 17) & 0x1) == 0)
11026                                                             {
11027                                                               if (((word >> 18) & 0x1) == 0)
11028                                                                 {
11029                                                                   /* 33222222222211111111110000000000
11030                                                                      10987654321098765432109876543210
11031                                                                      xxxxxxxxxx01xx01100x01xx1x100100
11032                                                                      uqincp.  */
11033                                                                   return 1944;
11034                                                                 }
11035                                                               else
11036                                                                 {
11037                                                                   /* 33222222222211111111110000000000
11038                                                                      10987654321098765432109876543210
11039                                                                      xxxxxxxxxx01xx01101x01xx1x100100
11040                                                                      decp.  */
11041                                                                   return 1318;
11042                                                                 }
11043                                                             }
11044                                                           else
11045                                                             {
11046                                                               /* 33222222222211111111110000000000
11047                                                                  10987654321098765432109876543210
11048                                                                  xxxxxxxxxx01xx0111xx01xx1x100100
11049                                                                  uqdecp.  */
11050                                                               return 1930;
11051                                                             }
11052                                                         }
11053                                                     }
11054                                                   else
11055                                                     {
11056                                                       if (((word >> 17) & 0x1) == 0)
11057                                                         {
11058                                                           /* 33222222222211111111110000000000
11059                                                              10987654321098765432109876543210
11060                                                              xxxxxxxxxx1xxx0110xx01xx1x100100
11061                                                              uqincp.  */
11062                                                           return 1945;
11063                                                         }
11064                                                       else
11065                                                         {
11066                                                           /* 33222222222211111111110000000000
11067                                                              10987654321098765432109876543210
11068                                                              xxxxxxxxxx1xxx0111xx01xx1x100100
11069                                                              uqdecp.  */
11070                                                           return 1931;
11071                                                         }
11072                                                     }
11073                                                 }
11074                                             }
11075                                           else
11076                                             {
11077                                               if (((word >> 22) & 0x1) == 0)
11078                                                 {
11079                                                   if (((word >> 23) & 0x1) == 0)
11080                                                     {
11081                                                       /* 33222222222211111111110000000000
11082                                                          10987654321098765432109876543210
11083                                                          xxxxxxxxxxxxxx01xxxx01001x100101
11084                                                          ld1sh.  */
11085                                                       return 1535;
11086                                                     }
11087                                                   else
11088                                                     {
11089                                                       /* 33222222222211111111110000000000
11090                                                          10987654321098765432109876543210
11091                                                          xxxxxxxxxxxxxx01xxxx01011x100101
11092                                                          ld1sb.  */
11093                                                       return 1522;
11094                                                     }
11095                                                 }
11096                                               else
11097                                                 {
11098                                                   if (((word >> 23) & 0x1) == 0)
11099                                                     {
11100                                                       /* 33222222222211111111110000000000
11101                                                          10987654321098765432109876543210
11102                                                          xxxxxxxxxxxxxx01xxxx01101x100101
11103                                                          ld1w.  */
11104                                                       return 1554;
11105                                                     }
11106                                                   else
11107                                                     {
11108                                                       /* 33222222222211111111110000000000
11109                                                          10987654321098765432109876543210
11110                                                          xxxxxxxxxxxxxx01xxxx01111x100101
11111                                                          ld1d.  */
11112                                                       return 1474;
11113                                                     }
11114                                                 }
11115                                             }
11116                                         }
11117                                       else
11118                                         {
11119                                           if (((word >> 22) & 0x1) == 0)
11120                                             {
11121                                               if (((word >> 23) & 0x1) == 0)
11122                                                 {
11123                                                   /* 33222222222211111111110000000000
11124                                                      10987654321098765432109876543210
11125                                                      xxxxxxxxxxxxxx01xxxx11001x10010x
11126                                                      ldnf1sh.  */
11127                                                   return 1652;
11128                                                 }
11129                                               else
11130                                                 {
11131                                                   /* 33222222222211111111110000000000
11132                                                      10987654321098765432109876543210
11133                                                      xxxxxxxxxxxxxx01xxxx11011x10010x
11134                                                      ldnf1sb.  */
11135                                                   return 1649;
11136                                                 }
11137                                             }
11138                                           else
11139                                             {
11140                                               if (((word >> 23) & 0x1) == 0)
11141                                                 {
11142                                                   /* 33222222222211111111110000000000
11143                                                      10987654321098765432109876543210
11144                                                      xxxxxxxxxxxxxx01xxxx11101x10010x
11145                                                      ldnf1w.  */
11146                                                   return 1655;
11147                                                 }
11148                                               else
11149                                                 {
11150                                                   /* 33222222222211111111110000000000
11151                                                      10987654321098765432109876543210
11152                                                      xxxxxxxxxxxxxx01xxxx11111x10010x
11153                                                      ldnf1d.  */
11154                                                   return 1644;
11155                                                 }
11156                                             }
11157                                         }
11158                                     }
11159                                   else
11160                                     {
11161                                       if (((word >> 31) & 0x1) == 0)
11162                                         {
11163                                           if (((word >> 16) & 0x1) == 0)
11164                                             {
11165                                               if (((word >> 17) & 0x1) == 0)
11166                                                 {
11167                                                   if (((word >> 18) & 0x1) == 0)
11168                                                     {
11169                                                       if (((word >> 19) & 0x1) == 0)
11170                                                         {
11171                                                           if (((word >> 20) & 0x1) == 0)
11172                                                             {
11173                                                               /* 33222222222211111111110000000000
11174                                                                  10987654321098765432109876543210
11175                                                                  xxxxxxxxxxxxxx11000001xx1x100100
11176                                                                  add.  */
11177                                                               return 1231;
11178                                                             }
11179                                                           else
11180                                                             {
11181                                                               /* 33222222222211111111110000000000
11182                                                                  10987654321098765432109876543210
11183                                                                  xxxxxxxxxxxxxx11000011xx1x100100
11184                                                                  mul.  */
11185                                                               return 1684;
11186                                                             }
11187                                                         }
11188                                                       else
11189                                                         {
11190                                                           if (((word >> 20) & 0x1) == 0)
11191                                                             {
11192                                                               /* 33222222222211111111110000000000
11193                                                                  10987654321098765432109876543210
11194                                                                  xxxxxxxxxxxxxx11000101xx1x100100
11195                                                                  smax.  */
11196                                                               return 1763;
11197                                                             }
11198                                                           else
11199                                                             {
11200                                                               /* 33222222222211111111110000000000
11201                                                                  10987654321098765432109876543210
11202                                                                  xxxxxxxxxxxxxx11000111xx1x100100
11203                                                                  dup.  */
11204                                                               return 1323;
11205                                                             }
11206                                                         }
11207                                                     }
11208                                                   else
11209                                                     {
11210                                                       /* 33222222222211111111110000000000
11211                                                          10987654321098765432109876543210
11212                                                          xxxxxxxxxxxxxx11001xx1xx1x100100
11213                                                          sqadd.  */
11214                                                       return 1772;
11215                                                     }
11216                                                 }
11217                                               else
11218                                                 {
11219                                                   if (((word >> 18) & 0x1) == 0)
11220                                                     {
11221                                                       /* 33222222222211111111110000000000
11222                                                          10987654321098765432109876543210
11223                                                          xxxxxxxxxxxxxx11010xx1xx1x100100
11224                                                          smin.  */
11225                                                       return 1766;
11226                                                     }
11227                                                   else
11228                                                     {
11229                                                       /* 33222222222211111111110000000000
11230                                                          10987654321098765432109876543210
11231                                                          xxxxxxxxxxxxxx11011xx1xx1x100100
11232                                                          sqsub.  */
11233                                                       return 1802;
11234                                                     }
11235                                                 }
11236                                             }
11237                                           else
11238                                             {
11239                                               if (((word >> 17) & 0x1) == 0)
11240                                                 {
11241                                                   if (((word >> 18) & 0x1) == 0)
11242                                                     {
11243                                                       if (((word >> 19) & 0x1) == 0)
11244                                                         {
11245                                                           /* 33222222222211111111110000000000
11246                                                              10987654321098765432109876543210
11247                                                              xxxxxxxxxxxxxx111000x1xx1x100100
11248                                                              sub.  */
11249                                                           return 1884;
11250                                                         }
11251                                                       else
11252                                                         {
11253                                                           if (((word >> 20) & 0x1) == 0)
11254                                                             {
11255                                                               /* 33222222222211111111110000000000
11256                                                                  10987654321098765432109876543210
11257                                                                  xxxxxxxxxxxxxx11100101xx1x100100
11258                                                                  umax.  */
11259                                                               return 1912;
11260                                                             }
11261                                                           else
11262                                                             {
11263                                                               /* 33222222222211111111110000000000
11264                                                                  10987654321098765432109876543210
11265                                                                  xxxxxxxxxxxxxx11100111xx1x100100
11266                                                                  fdup.  */
11267                                                               return 1379;
11268                                                             }
11269                                                         }
11270                                                     }
11271                                                   else
11272                                                     {
11273                                                       /* 33222222222211111111110000000000
11274                                                          10987654321098765432109876543210
11275                                                          xxxxxxxxxxxxxx11101xx1xx1x100100
11276                                                          uqadd.  */
11277                                                       return 1920;
11278                                                     }
11279                                                 }
11280                                               else
11281                                                 {
11282                                                   if (((word >> 18) & 0x1) == 0)
11283                                                     {
11284                                                       if (((word >> 19) & 0x1) == 0)
11285                                                         {
11286                                                           /* 33222222222211111111110000000000
11287                                                              10987654321098765432109876543210
11288                                                              xxxxxxxxxxxxxx111100x1xx1x100100
11289                                                              subr.  */
11290                                                           return 1886;
11291                                                         }
11292                                                       else
11293                                                         {
11294                                                           /* 33222222222211111111110000000000
11295                                                              10987654321098765432109876543210
11296                                                              xxxxxxxxxxxxxx111101x1xx1x100100
11297                                                              umin.  */
11298                                                           return 1915;
11299                                                         }
11300                                                     }
11301                                                   else
11302                                                     {
11303                                                       /* 33222222222211111111110000000000
11304                                                          10987654321098765432109876543210
11305                                                          xxxxxxxxxxxxxx11111xx1xx1x100100
11306                                                          uqsub.  */
11307                                                       return 1950;
11308                                                     }
11309                                                 }
11310                                             }
11311                                         }
11312                                       else
11313                                         {
11314                                           if (((word >> 13) & 0x1) == 0)
11315                                             {
11316                                               if (((word >> 22) & 0x1) == 0)
11317                                                 {
11318                                                   if (((word >> 23) & 0x1) == 0)
11319                                                     {
11320                                                       /* 33222222222211111111110000000000
11321                                                          10987654321098765432109876543210
11322                                                          xxxxxxxxxxxxx011xxxxx1001x100101
11323                                                          ld2w.  */
11324                                                       return 1562;
11325                                                     }
11326                                                   else
11327                                                     {
11328                                                       /* 33222222222211111111110000000000
11329                                                          10987654321098765432109876543210
11330                                                          xxxxxxxxxxxxx011xxxxx1011x100101
11331                                                          ld2d.  */
11332                                                       return 1558;
11333                                                     }
11334                                                 }
11335                                               else
11336                                                 {
11337                                                   if (((word >> 23) & 0x1) == 0)
11338                                                     {
11339                                                       /* 33222222222211111111110000000000
11340                                                          10987654321098765432109876543210
11341                                                          xxxxxxxxxxxxx011xxxxx1101x100101
11342                                                          ld4w.  */
11343                                                       return 1578;
11344                                                     }
11345                                                   else
11346                                                     {
11347                                                       /* 33222222222211111111110000000000
11348                                                          10987654321098765432109876543210
11349                                                          xxxxxxxxxxxxx011xxxxx1111x100101
11350                                                          ld4d.  */
11351                                                       return 1574;
11352                                                     }
11353                                                 }
11354                                             }
11355                                           else
11356                                             {
11357                                               if (((word >> 22) & 0x1) == 0)
11358                                                 {
11359                                                   if (((word >> 23) & 0x1) == 0)
11360                                                     {
11361                                                       /* 33222222222211111111110000000000
11362                                                          10987654321098765432109876543210
11363                                                          xxxxxxxxxxxxx111xxxxx1001x100101
11364                                                          ld2w.  */
11365                                                       return 1563;
11366                                                     }
11367                                                   else
11368                                                     {
11369                                                       /* 33222222222211111111110000000000
11370                                                          10987654321098765432109876543210
11371                                                          xxxxxxxxxxxxx111xxxxx1011x100101
11372                                                          ld2d.  */
11373                                                       return 1559;
11374                                                     }
11375                                                 }
11376                                               else
11377                                                 {
11378                                                   if (((word >> 23) & 0x1) == 0)
11379                                                     {
11380                                                       /* 33222222222211111111110000000000
11381                                                          10987654321098765432109876543210
11382                                                          xxxxxxxxxxxxx111xxxxx1101x100101
11383                                                          ld4w.  */
11384                                                       return 1579;
11385                                                     }
11386                                                   else
11387                                                     {
11388                                                       /* 33222222222211111111110000000000
11389                                                          10987654321098765432109876543210
11390                                                          xxxxxxxxxxxxx111xxxxx1111x100101
11391                                                          ld4d.  */
11392                                                       return 1575;
11393                                                     }
11394                                                 }
11395                                             }
11396                                         }
11397                                     }
11398                                 }
11399                               else
11400                                 {
11401                                   if (((word >> 13) & 0x1) == 0)
11402                                     {
11403                                       if (((word >> 31) & 0x1) == 0)
11404                                         {
11405                                           if (((word >> 14) & 0x1) == 0)
11406                                             {
11407                                               /* 33222222222211111111110000000000
11408                                                  10987654321098765432109876543210
11409                                                  xxxxxxxxxxxxx001xxxxx1xx1x100110
11410                                                  fmad.  */
11411                                               return 1381;
11412                                             }
11413                                           else
11414                                             {
11415                                               /* 33222222222211111111110000000000
11416                                                  10987654321098765432109876543210
11417                                                  xxxxxxxxxxxxx011xxxxx1xx1x100110
11418                                                  fnmad.  */
11419                                               return 1411;
11420                                             }
11421                                         }
11422                                       else
11423                                         {
11424                                           if (((word >> 22) & 0x1) == 0)
11425                                             {
11426                                               if (((word >> 23) & 0x1) == 0)
11427                                                 {
11428                                                   /* 33222222222211111111110000000000
11429                                                      10987654321098765432109876543210
11430                                                      xxxxxxxxxxxxx0x1xxxxx1001x100111
11431                                                      st1w.  */
11432                                                   return 1839;
11433                                                 }
11434                                               else
11435                                                 {
11436                                                   /* 33222222222211111111110000000000
11437                                                      10987654321098765432109876543210
11438                                                      xxxxxxxxxxxxx0x1xxxxx1011x100111
11439                                                      st1d.  */
11440                                                   return 1818;
11441                                                 }
11442                                             }
11443                                           else
11444                                             {
11445                                               /* 33222222222211111111110000000000
11446                                                  10987654321098765432109876543210
11447                                                  xxxxxxxxxxxxx0x1xxxxx11x1x100111
11448                                                  st1w.  */
11449                                               return 1844;
11450                                             }
11451                                         }
11452                                     }
11453                                   else
11454                                     {
11455                                       if (((word >> 14) & 0x1) == 0)
11456                                         {
11457                                           if (((word >> 31) & 0x1) == 0)
11458                                             {
11459                                               /* 33222222222211111111110000000000
11460                                                  10987654321098765432109876543210
11461                                                  xxxxxxxxxxxxx101xxxxx1xx1x100110
11462                                                  fmsb.  */
11463                                               return 1402;
11464                                             }
11465                                           else
11466                                             {
11467                                               if (((word >> 22) & 0x1) == 0)
11468                                                 {
11469                                                   if (((word >> 23) & 0x1) == 0)
11470                                                     {
11471                                                       /* 33222222222211111111110000000000
11472                                                          10987654321098765432109876543210
11473                                                          xxxxxxxxxxxxx101xxxxx1001x100111
11474                                                          st1w.  */
11475                                                       return 1840;
11476                                                     }
11477                                                   else
11478                                                     {
11479                                                       /* 33222222222211111111110000000000
11480                                                          10987654321098765432109876543210
11481                                                          xxxxxxxxxxxxx101xxxxx1011x100111
11482                                                          st1d.  */
11483                                                       return 1819;
11484                                                     }
11485                                                 }
11486                                               else
11487                                                 {
11488                                                   /* 33222222222211111111110000000000
11489                                                      10987654321098765432109876543210
11490                                                      xxxxxxxxxxxxx101xxxxx11x1x100111
11491                                                      st1w.  */
11492                                                   return 1847;
11493                                                 }
11494                                             }
11495                                         }
11496                                       else
11497                                         {
11498                                           if (((word >> 31) & 0x1) == 0)
11499                                             {
11500                                               /* 33222222222211111111110000000000
11501                                                  10987654321098765432109876543210
11502                                                  xxxxxxxxxxxxx111xxxxx1xx1x100110
11503                                                  fnmsb.  */
11504                                               return 1414;
11505                                             }
11506                                           else
11507                                             {
11508                                               if (((word >> 20) & 0x1) == 0)
11509                                                 {
11510                                                   if (((word >> 23) & 0x1) == 0)
11511                                                     {
11512                                                       /* 33222222222211111111110000000000
11513                                                          10987654321098765432109876543210
11514                                                          xxxxxxxxxxxxx111xxxx01x01x100111
11515                                                          st1w.  */
11516                                                       return 1848;
11517                                                     }
11518                                                   else
11519                                                     {
11520                                                       /* 33222222222211111111110000000000
11521                                                          10987654321098765432109876543210
11522                                                          xxxxxxxxxxxxx111xxxx01x11x100111
11523                                                          st1d.  */
11524                                                       return 1822;
11525                                                     }
11526                                                 }
11527                                               else
11528                                                 {
11529                                                   if (((word >> 22) & 0x1) == 0)
11530                                                     {
11531                                                       if (((word >> 23) & 0x1) == 0)
11532                                                         {
11533                                                           /* 33222222222211111111110000000000
11534                                                              10987654321098765432109876543210
11535                                                              xxxxxxxxxxxxx111xxxx11001x100111
11536                                                              st2w.  */
11537                                                           return 1856;
11538                                                         }
11539                                                       else
11540                                                         {
11541                                                           /* 33222222222211111111110000000000
11542                                                              10987654321098765432109876543210
11543                                                              xxxxxxxxxxxxx111xxxx11011x100111
11544                                                              st2d.  */
11545                                                           return 1852;
11546                                                         }
11547                                                     }
11548                                                   else
11549                                                     {
11550                                                       if (((word >> 23) & 0x1) == 0)
11551                                                         {
11552                                                           /* 33222222222211111111110000000000
11553                                                              10987654321098765432109876543210
11554                                                              xxxxxxxxxxxxx111xxxx11101x100111
11555                                                              st4w.  */
11556                                                           return 1872;
11557                                                         }
11558                                                       else
11559                                                         {
11560                                                           /* 33222222222211111111110000000000
11561                                                              10987654321098765432109876543210
11562                                                              xxxxxxxxxxxxx111xxxx11111x100111
11563                                                              st4d.  */
11564                                                           return 1868;
11565                                                         }
11566                                                     }
11567                                                 }
11568                                             }
11569                                         }
11570                                     }
11571                                 }
11572                             }
11573                         }
11574                     }
11575                 }
11576             }
11577           else
11578             {
11579               if (((word >> 29) & 0x1) == 0)
11580                 {
11581                   if (((word >> 30) & 0x1) == 0)
11582                     {
11583                       if (((word >> 31) & 0x1) == 0)
11584                         {
11585                           /* 33222222222211111111110000000000
11586                              10987654321098765432109876543210
11587                              xxxxxxxxxxxxxxxxxxxxxxxxxx101000
11588                              b.  */
11589                           return 630;
11590                         }
11591                       else
11592                         {
11593                           /* 33222222222211111111110000000000
11594                              10987654321098765432109876543210
11595                              xxxxxxxxxxxxxxxxxxxxxxxxxx101001
11596                              bl.  */
11597                           return 631;
11598                         }
11599                     }
11600                   else
11601                     {
11602                       if (((word >> 24) & 0x1) == 0)
11603                         {
11604                           if (((word >> 4) & 0x1) == 0)
11605                             {
11606                               if (((word >> 25) & 0x1) == 0)
11607                                 {
11608                                   if (((word >> 31) & 0x1) == 0)
11609                                     {
11610                                       /* 33222222222211111111110000000000
11611                                          10987654321098765432109876543210
11612                                          xxxx0xxxxxxxxxxxxxxxxxxx00101010
11613                                          b.c.  */
11614                                       return 651;
11615                                     }
11616                                   else
11617                                     {
11618                                       if (((word >> 0) & 0x1) == 0)
11619                                         {
11620                                           if (((word >> 1) & 0x1) == 0)
11621                                             {
11622                                               if (((word >> 21) & 0x1) == 0)
11623                                                 {
11624                                                   /* 33222222222211111111110000000000
11625                                                      10987654321098765432109876543210
11626                                                      00xx0xxxxxxxxxxxxxxxx0xx00101011
11627                                                      hlt.  */
11628                                                   return 742;
11629                                                 }
11630                                               else
11631                                                 {
11632                                                   /* 33222222222211111111110000000000
11633                                                      10987654321098765432109876543210
11634                                                      00xx0xxxxxxxxxxxxxxxx1xx00101011
11635                                                      brk.  */
11636                                                   return 741;
11637                                                 }
11638                                             }
11639                                           else
11640                                             {
11641                                               if (((word >> 21) & 0x1) == 0)
11642                                                 {
11643                                                   /* 33222222222211111111110000000000
11644                                                      10987654321098765432109876543210
11645                                                      01xx0xxxxxxxxxxxxxxxx0xx00101011
11646                                                      hvc.  */
11647                                                   return 739;
11648                                                 }
11649                                               else
11650                                                 {
11651                                                   /* 33222222222211111111110000000000
11652                                                      10987654321098765432109876543210
11653                                                      01xx0xxxxxxxxxxxxxxxx1xx00101011
11654                                                      dcps2.  */
11655                                                   return 744;
11656                                                 }
11657                                             }
11658                                         }
11659                                       else
11660                                         {
11661                                           if (((word >> 1) & 0x1) == 0)
11662                                             {
11663                                               if (((word >> 21) & 0x1) == 0)
11664                                                 {
11665                                                   /* 33222222222211111111110000000000
11666                                                      10987654321098765432109876543210
11667                                                      10xx0xxxxxxxxxxxxxxxx0xx00101011
11668                                                      svc.  */
11669                                                   return 738;
11670                                                 }
11671                                               else
11672                                                 {
11673                                                   /* 33222222222211111111110000000000
11674                                                      10987654321098765432109876543210
11675                                                      10xx0xxxxxxxxxxxxxxxx1xx00101011
11676                                                      dcps1.  */
11677                                                   return 743;
11678                                                 }
11679                                             }
11680                                           else
11681                                             {
11682                                               if (((word >> 21) & 0x1) == 0)
11683                                                 {
11684                                                   /* 33222222222211111111110000000000
11685                                                      10987654321098765432109876543210
11686                                                      11xx0xxxxxxxxxxxxxxxx0xx00101011
11687                                                      smc.  */
11688                                                   return 740;
11689                                                 }
11690                                               else
11691                                                 {
11692                                                   /* 33222222222211111111110000000000
11693                                                      10987654321098765432109876543210
11694                                                      11xx0xxxxxxxxxxxxxxxx1xx00101011
11695                                                      dcps3.  */
11696                                                   return 745;
11697                                                 }
11698                                             }
11699                                         }
11700                                     }
11701                                 }
11702                               else
11703                                 {
11704                                   if (((word >> 21) & 0x1) == 0)
11705                                     {
11706                                       if (((word >> 22) & 0x1) == 0)
11707                                         {
11708                                           if (((word >> 23) & 0x1) == 0)
11709                                             {
11710                                               /* 33222222222211111111110000000000
11711                                                  10987654321098765432109876543210
11712                                                  xxxx0xxxxxxxxxxxxxxxx0000110101x
11713                                                  br.  */
11714                                               return 632;
11715                                             }
11716                                           else
11717                                             {
11718                                               /* 33222222222211111111110000000000
11719                                                  10987654321098765432109876543210
11720                                                  xxxx0xxxxxxxxxxxxxxxx0010110101x
11721                                                  eret.  */
11722                                               return 635;
11723                                             }
11724                                         }
11725                                       else
11726                                         {
11727                                           /* 33222222222211111111110000000000
11728                                              10987654321098765432109876543210
11729                                              xxxx0xxxxxxxxxxxxxxxx01x0110101x
11730                                              ret.  */
11731                                           return 634;
11732                                         }
11733                                     }
11734                                   else
11735                                     {
11736                                       if (((word >> 23) & 0x1) == 0)
11737                                         {
11738                                           /* 33222222222211111111110000000000
11739                                              10987654321098765432109876543210
11740                                              xxxx0xxxxxxxxxxxxxxxx1x00110101x
11741                                              blr.  */
11742                                           return 633;
11743                                         }
11744                                       else
11745                                         {
11746                                           /* 33222222222211111111110000000000
11747                                              10987654321098765432109876543210
11748                                              xxxx0xxxxxxxxxxxxxxxx1x10110101x
11749                                              drps.  */
11750                                           return 636;
11751                                         }
11752                                     }
11753                                 }
11754                             }
11755                           else
11756                             {
11757                               if (((word >> 10) & 0x1) == 0)
11758                                 {
11759                                   if (((word >> 21) & 0x1) == 0)
11760                                     {
11761                                       if (((word >> 22) & 0x1) == 0)
11762                                         {
11763                                           if (((word >> 23) & 0x1) == 0)
11764                                             {
11765                                               /* 33222222222211111111110000000000
11766                                                  10987654321098765432109876543210
11767                                                  xxxx1xxxxx0xxxxxxxxxx0000x10101x
11768                                                  braaz.  */
11769                                               return 641;
11770                                             }
11771                                           else
11772                                             {
11773                                               /* 33222222222211111111110000000000
11774                                                  10987654321098765432109876543210
11775                                                  xxxx1xxxxx0xxxxxxxxxx0010x10101x
11776                                                  eretaa.  */
11777                                               return 647;
11778                                             }
11779                                         }
11780                                       else
11781                                         {
11782                                           /* 33222222222211111111110000000000
11783                                              10987654321098765432109876543210
11784                                              xxxx1xxxxx0xxxxxxxxxx01x0x10101x
11785                                              retaa.  */
11786                                           return 645;
11787                                         }
11788                                     }
11789                                   else
11790                                     {
11791                                       /* 33222222222211111111110000000000
11792                                          10987654321098765432109876543210
11793                                          xxxx1xxxxx0xxxxxxxxxx1xx0x10101x
11794                                          blraaz.  */
11795                                       return 643;
11796                                     }
11797                                 }
11798                               else
11799                                 {
11800                                   if (((word >> 21) & 0x1) == 0)
11801                                     {
11802                                       if (((word >> 22) & 0x1) == 0)
11803                                         {
11804                                           if (((word >> 23) & 0x1) == 0)
11805                                             {
11806                                               /* 33222222222211111111110000000000
11807                                                  10987654321098765432109876543210
11808                                                  xxxx1xxxxx1xxxxxxxxxx0000x10101x
11809                                                  brabz.  */
11810                                               return 642;
11811                                             }
11812                                           else
11813                                             {
11814                                               /* 33222222222211111111110000000000
11815                                                  10987654321098765432109876543210
11816                                                  xxxx1xxxxx1xxxxxxxxxx0010x10101x
11817                                                  eretab.  */
11818                                               return 648;
11819                                             }
11820                                         }
11821                                       else
11822                                         {
11823                                           /* 33222222222211111111110000000000
11824                                              10987654321098765432109876543210
11825                                              xxxx1xxxxx1xxxxxxxxxx01x0x10101x
11826                                              retab.  */
11827                                           return 646;
11828                                         }
11829                                     }
11830                                   else
11831                                     {
11832                                       /* 33222222222211111111110000000000
11833                                          10987654321098765432109876543210
11834                                          xxxx1xxxxx1xxxxxxxxxx1xx0x10101x
11835                                          blrabz.  */
11836                                       return 644;
11837                                     }
11838                                 }
11839                             }
11840                         }
11841                       else
11842                         {
11843                           if (((word >> 21) & 0x1) == 0)
11844                             {
11845                               if (((word >> 25) & 0x1) == 0)
11846                                 {
11847                                   /* 33222222222211111111110000000000
11848                                      10987654321098765432109876543210
11849                                      xxxxxxxxxxxxxxxxxxxxx0xx1010101x
11850                                      msr.  */
11851                                   return 1157;
11852                                 }
11853                               else
11854                                 {
11855                                   if (((word >> 10) & 0x1) == 0)
11856                                     {
11857                                       /* 33222222222211111111110000000000
11858                                          10987654321098765432109876543210
11859                                          xxxxxxxxxx0xxxxxxxxxx0xx1110101x
11860                                          braa.  */
11861                                       return 637;
11862                                     }
11863                                   else
11864                                     {
11865                                       /* 33222222222211111111110000000000
11866                                          10987654321098765432109876543210
11867                                          xxxxxxxxxx1xxxxxxxxxx0xx1110101x
11868                                          brab.  */
11869                                       return 638;
11870                                     }
11871                                 }
11872                             }
11873                           else
11874                             {
11875                               if (((word >> 25) & 0x1) == 0)
11876                                 {
11877                                   /* 33222222222211111111110000000000
11878                                      10987654321098765432109876543210
11879                                      xxxxxxxxxxxxxxxxxxxxx1xx1010101x
11880                                      sysl.  */
11881                                   return 1182;
11882                                 }
11883                               else
11884                                 {
11885                                   if (((word >> 10) & 0x1) == 0)
11886                                     {
11887                                       /* 33222222222211111111110000000000
11888                                          10987654321098765432109876543210
11889                                          xxxxxxxxxx0xxxxxxxxxx1xx1110101x
11890                                          blraa.  */
11891                                       return 639;
11892                                     }
11893                                   else
11894                                     {
11895                                       /* 33222222222211111111110000000000
11896                                          10987654321098765432109876543210
11897                                          xxxxxxxxxx1xxxxxxxxxx1xx1110101x
11898                                          blrab.  */
11899                                       return 640;
11900                                     }
11901                                 }
11902                             }
11903                         }
11904                     }
11905                 }
11906               else
11907                 {
11908                   if (((word >> 24) & 0x1) == 0)
11909                     {
11910                       if (((word >> 25) & 0x1) == 0)
11911                         {
11912                           /* 33222222222211111111110000000000
11913                              10987654321098765432109876543210
11914                              xxxxxxxxxxxxxxxxxxxxxxxx001011xx
11915                              cbz.  */
11916                           return 649;
11917                         }
11918                       else
11919                         {
11920                           /* 33222222222211111111110000000000
11921                              10987654321098765432109876543210
11922                              xxxxxxxxxxxxxxxxxxxxxxxx011011xx
11923                              tbz.  */
11924                           return 1192;
11925                         }
11926                     }
11927                   else
11928                     {
11929                       if (((word >> 25) & 0x1) == 0)
11930                         {
11931                           /* 33222222222211111111110000000000
11932                              10987654321098765432109876543210
11933                              xxxxxxxxxxxxxxxxxxxxxxxx101011xx
11934                              cbnz.  */
11935                           return 650;
11936                         }
11937                       else
11938                         {
11939                           /* 33222222222211111111110000000000
11940                              10987654321098765432109876543210
11941                              xxxxxxxxxxxxxxxxxxxxxxxx111011xx
11942                              tbnz.  */
11943                           return 1193;
11944                         }
11945                     }
11946                 }
11947             }
11948         }
11949       else
11950         {
11951           if (((word >> 25) & 0x1) == 0)
11952             {
11953               if (((word >> 28) & 0x1) == 0)
11954                 {
11955                   if (((word >> 22) & 0x1) == 0)
11956                     {
11957                       if (((word >> 23) & 0x1) == 0)
11958                         {
11959                           if (((word >> 24) & 0x1) == 0)
11960                             {
11961                               if (((word >> 29) & 0x1) == 0)
11962                                 {
11963                                   /* 33222222222211111111110000000000
11964                                      10987654321098765432109876543210
11965                                      xxxxxxxxxxxxxxxxxxxxxx00001100xx
11966                                      st4.  */
11967                                   return 434;
11968                                 }
11969                               else
11970                                 {
11971                                   /* 33222222222211111111110000000000
11972                                      10987654321098765432109876543210
11973                                      xxxxxxxxxxxxxxxxxxxxxx00001101xx
11974                                      stnp.  */
11975                                   return 943;
11976                                 }
11977                             }
11978                           else
11979                             {
11980                               if (((word >> 29) & 0x1) == 0)
11981                                 {
11982                                   if (((word >> 13) & 0x1) == 0)
11983                                     {
11984                                       if (((word >> 21) & 0x1) == 0)
11985                                         {
11986                                           /* 33222222222211111111110000000000
11987                                              10987654321098765432109876543210
11988                                              xxxxxxxxxxxxx0xxxxxxx000101100xx
11989                                              st1.  */
11990                                           return 450;
11991                                         }
11992                                       else
11993                                         {
11994                                           /* 33222222222211111111110000000000
11995                                              10987654321098765432109876543210
11996                                              xxxxxxxxxxxxx0xxxxxxx100101100xx
11997                                              st2.  */
11998                                           return 452;
11999                                         }
12000                                     }
12001                                   else
12002                                     {
12003                                       if (((word >> 21) & 0x1) == 0)
12004                                         {
12005                                           /* 33222222222211111111110000000000
12006                                              10987654321098765432109876543210
12007                                              xxxxxxxxxxxxx1xxxxxxx000101100xx
12008                                              st3.  */
12009                                           return 451;
12010                                         }
12011                                       else
12012                                         {
12013                                           /* 33222222222211111111110000000000
12014                                              10987654321098765432109876543210
12015                                              xxxxxxxxxxxxx1xxxxxxx100101100xx
12016                                              st4.  */
12017                                           return 453;
12018                                         }
12019                                     }
12020                                 }
12021                               else
12022                                 {
12023                                   /* 33222222222211111111110000000000
12024                                      10987654321098765432109876543210
12025                                      xxxxxxxxxxxxxxxxxxxxxx00101101xx
12026                                      stp.  */
12027                                   return 947;
12028                                 }
12029                             }
12030                         }
12031                       else
12032                         {
12033                           if (((word >> 29) & 0x1) == 0)
12034                             {
12035                               if (((word >> 21) & 0x1) == 0)
12036                                 {
12037                                   if (((word >> 24) & 0x1) == 0)
12038                                     {
12039                                       /* 33222222222211111111110000000000
12040                                          10987654321098765432109876543210
12041                                          xxxxxxxxxxxxxxxxxxxxx001001100xx
12042                                          st4.  */
12043                                       return 442;
12044                                     }
12045                                   else
12046                                     {
12047                                       if (((word >> 13) & 0x1) == 0)
12048                                         {
12049                                           /* 33222222222211111111110000000000
12050                                              10987654321098765432109876543210
12051                                              xxxxxxxxxxxxx0xxxxxxx001101100xx
12052                                              st1.  */
12053                                           return 462;
12054                                         }
12055                                       else
12056                                         {
12057                                           /* 33222222222211111111110000000000
12058                                              10987654321098765432109876543210
12059                                              xxxxxxxxxxxxx1xxxxxxx001101100xx
12060                                              st3.  */
12061                                           return 463;
12062                                         }
12063                                     }
12064                                 }
12065                               else
12066                                 {
12067                                   if (((word >> 13) & 0x1) == 0)
12068                                     {
12069                                       /* 33222222222211111111110000000000
12070                                          10987654321098765432109876543210
12071                                          xxxxxxxxxxxxx0xxxxxxx101x01100xx
12072                                          st2.  */
12073                                       return 464;
12074                                     }
12075                                   else
12076                                     {
12077                                       /* 33222222222211111111110000000000
12078                                          10987654321098765432109876543210
12079                                          xxxxxxxxxxxxx1xxxxxxx101x01100xx
12080                                          st4.  */
12081                                       return 465;
12082                                     }
12083                                 }
12084                             }
12085                           else
12086                             {
12087                               /* 33222222222211111111110000000000
12088                                  10987654321098765432109876543210
12089                                  xxxxxxxxxxxxxxxxxxxxxx01x01101xx
12090                                  stp.  */
12091                               return 952;
12092                             }
12093                         }
12094                     }
12095                   else
12096                     {
12097                       if (((word >> 23) & 0x1) == 0)
12098                         {
12099                           if (((word >> 24) & 0x1) == 0)
12100                             {
12101                               if (((word >> 29) & 0x1) == 0)
12102                                 {
12103                                   /* 33222222222211111111110000000000
12104                                      10987654321098765432109876543210
12105                                      xxxxxxxxxxxxxxxxxxxxxx10001100xx
12106                                      ld4.  */
12107                                   return 438;
12108                                 }
12109                               else
12110                                 {
12111                                   /* 33222222222211111111110000000000
12112                                      10987654321098765432109876543210
12113                                      xxxxxxxxxxxxxxxxxxxxxx10001101xx
12114                                      ldnp.  */
12115                                   return 944;
12116                                 }
12117                             }
12118                           else
12119                             {
12120                               if (((word >> 29) & 0x1) == 0)
12121                                 {
12122                                   if (((word >> 13) & 0x1) == 0)
12123                                     {
12124                                       if (((word >> 21) & 0x1) == 0)
12125                                         {
12126                                           /* 33222222222211111111110000000000
12127                                              10987654321098765432109876543210
12128                                              xxxxxxxxxxxxx0xxxxxxx010101100xx
12129                                              ld1.  */
12130                                           return 454;
12131                                         }
12132                                       else
12133                                         {
12134                                           /* 33222222222211111111110000000000
12135                                              10987654321098765432109876543210
12136                                              xxxxxxxxxxxxx0xxxxxxx110101100xx
12137                                              ld2.  */
12138                                           return 458;
12139                                         }
12140                                     }
12141                                   else
12142                                     {
12143                                       if (((word >> 21) & 0x1) == 0)
12144                                         {
12145                                           /* 33222222222211111111110000000000
12146                                              10987654321098765432109876543210
12147                                              xxxxxxxxxxxxx1xxxxxxx010101100xx
12148                                              ld3.  */
12149                                           return 455;
12150                                         }
12151                                       else
12152                                         {
12153                                           /* 33222222222211111111110000000000
12154                                              10987654321098765432109876543210
12155                                              xxxxxxxxxxxxx1xxxxxxx110101100xx
12156                                              ld4.  */
12157                                           return 459;
12158                                         }
12159                                     }
12160                                 }
12161                               else
12162                                 {
12163                                   /* 33222222222211111111110000000000
12164                                      10987654321098765432109876543210
12165                                      xxxxxxxxxxxxxxxxxxxxxx10101101xx
12166                                      ldp.  */
12167                                   return 948;
12168                                 }
12169                             }
12170                         }
12171                       else
12172                         {
12173                           if (((word >> 29) & 0x1) == 0)
12174                             {
12175                               if (((word >> 21) & 0x1) == 0)
12176                                 {
12177                                   if (((word >> 24) & 0x1) == 0)
12178                                     {
12179                                       /* 33222222222211111111110000000000
12180                                          10987654321098765432109876543210
12181                                          xxxxxxxxxxxxxxxxxxxxx011001100xx
12182                                          ld4.  */
12183                                       return 446;
12184                                     }
12185                                   else
12186                                     {
12187                                       if (((word >> 13) & 0x1) == 0)
12188                                         {
12189                                           /* 33222222222211111111110000000000
12190                                              10987654321098765432109876543210
12191                                              xxxxxxxxxxxxx0xxxxxxx011101100xx
12192                                              ld1.  */
12193                                           return 466;
12194                                         }
12195                                       else
12196                                         {
12197                                           /* 33222222222211111111110000000000
12198                                              10987654321098765432109876543210
12199                                              xxxxxxxxxxxxx1xxxxxxx011101100xx
12200                                              ld3.  */
12201                                           return 467;
12202                                         }
12203                                     }
12204                                 }
12205                               else
12206                                 {
12207                                   if (((word >> 13) & 0x1) == 0)
12208                                     {
12209                                       /* 33222222222211111111110000000000
12210                                          10987654321098765432109876543210
12211                                          xxxxxxxxxxxxx0xxxxxxx111x01100xx
12212                                          ld2.  */
12213                                       return 470;
12214                                     }
12215                                   else
12216                                     {
12217                                       /* 33222222222211111111110000000000
12218                                          10987654321098765432109876543210
12219                                          xxxxxxxxxxxxx1xxxxxxx111x01100xx
12220                                          ld4.  */
12221                                       return 471;
12222                                     }
12223                                 }
12224                             }
12225                           else
12226                             {
12227                               /* 33222222222211111111110000000000
12228                                  10987654321098765432109876543210
12229                                  xxxxxxxxxxxxxxxxxxxxxx11x01101xx
12230                                  ldp.  */
12231                               return 953;
12232                             }
12233                         }
12234                     }
12235                 }
12236               else
12237                 {
12238                   if (((word >> 24) & 0x1) == 0)
12239                     {
12240                       if (((word >> 29) & 0x1) == 0)
12241                         {
12242                           /* 33222222222211111111110000000000
12243                              10987654321098765432109876543210
12244                              xxxxxxxxxxxxxxxxxxxxxxxx001110xx
12245                              ldr.  */
12246                           return 956;
12247                         }
12248                       else
12249                         {
12250                           if (((word >> 10) & 0x1) == 0)
12251                             {
12252                               if (((word >> 11) & 0x1) == 0)
12253                                 {
12254                                   if (((word >> 22) & 0x1) == 0)
12255                                     {
12256                                       /* 33222222222211111111110000000000
12257                                          10987654321098765432109876543210
12258                                          xxxxxxxxxx00xxxxxxxxxx0x001111xx
12259                                          stur.  */
12260                                       return 899;
12261                                     }
12262                                   else
12263                                     {
12264                                       /* 33222222222211111111110000000000
12265                                          10987654321098765432109876543210
12266                                          xxxxxxxxxx00xxxxxxxxxx1x001111xx
12267                                          ldur.  */
12268                                       return 900;
12269                                     }
12270                                 }
12271                               else
12272                                 {
12273                                   if (((word >> 22) & 0x1) == 0)
12274                                     {
12275                                       /* 33222222222211111111110000000000
12276                                          10987654321098765432109876543210
12277                                          xxxxxxxxxx01xxxxxxxxxx0x001111xx
12278                                          str.  */
12279                                       return 878;
12280                                     }
12281                                   else
12282                                     {
12283                                       /* 33222222222211111111110000000000
12284                                          10987654321098765432109876543210
12285                                          xxxxxxxxxx01xxxxxxxxxx1x001111xx
12286                                          ldr.  */
12287                                       return 879;
12288                                     }
12289                                 }
12290                             }
12291                           else
12292                             {
12293                               if (((word >> 22) & 0x1) == 0)
12294                                 {
12295                                   /* 33222222222211111111110000000000
12296                                      10987654321098765432109876543210
12297                                      xxxxxxxxxx1xxxxxxxxxxx0x001111xx
12298                                      str.  */
12299                                   return 855;
12300                                 }
12301                               else
12302                                 {
12303                                   /* 33222222222211111111110000000000
12304                                      10987654321098765432109876543210
12305                                      xxxxxxxxxx1xxxxxxxxxxx1x001111xx
12306                                      ldr.  */
12307                                   return 856;
12308                                 }
12309                             }
12310                         }
12311                     }
12312                   else
12313                     {
12314                       if (((word >> 22) & 0x1) == 0)
12315                         {
12316                           /* 33222222222211111111110000000000
12317                              10987654321098765432109876543210
12318                              xxxxxxxxxxxxxxxxxxxxxx0x10111xxx
12319                              str.  */
12320                           return 866;
12321                         }
12322                       else
12323                         {
12324                           /* 33222222222211111111110000000000
12325                              10987654321098765432109876543210
12326                              xxxxxxxxxxxxxxxxxxxxxx1x10111xxx
12327                              ldr.  */
12328                           return 867;
12329                         }
12330                     }
12331                 }
12332             }
12333           else
12334             {
12335               if (((word >> 24) & 0x1) == 0)
12336                 {
12337                   if (((word >> 21) & 0x1) == 0)
12338                     {
12339                       if (((word >> 28) & 0x1) == 0)
12340                         {
12341                           if (((word >> 10) & 0x1) == 0)
12342                             {
12343                               if (((word >> 29) & 0x1) == 0)
12344                                 {
12345                                   if (((word >> 11) & 0x1) == 0)
12346                                     {
12347                                       if (((word >> 12) & 0x1) == 0)
12348                                         {
12349                                           /* 33222222222211111111110000000000
12350                                              10987654321098765432109876543210
12351                                              xxxxxxxxxx000xxxxxxxx0xx011100xx
12352                                              tbl.  */
12353                                           return 414;
12354                                         }
12355                                       else
12356                                         {
12357                                           /* 33222222222211111111110000000000
12358                                              10987654321098765432109876543210
12359                                              xxxxxxxxxx001xxxxxxxx0xx011100xx
12360                                              tbx.  */
12361                                           return 415;
12362                                         }
12363                                     }
12364                                   else
12365                                     {
12366                                       if (((word >> 12) & 0x1) == 0)
12367                                         {
12368                                           if (((word >> 14) & 0x1) == 0)
12369                                             {
12370                                               /* 33222222222211111111110000000000
12371                                                  10987654321098765432109876543210
12372                                                  xxxxxxxxxx010x0xxxxxx0xx011100xx
12373                                                  trn1.  */
12374                                               return 257;
12375                                             }
12376                                           else
12377                                             {
12378                                               /* 33222222222211111111110000000000
12379                                                  10987654321098765432109876543210
12380                                                  xxxxxxxxxx010x1xxxxxx0xx011100xx
12381                                                  trn2.  */
12382                                               return 260;
12383                                             }
12384                                         }
12385                                       else
12386                                         {
12387                                           if (((word >> 13) & 0x1) == 0)
12388                                             {
12389                                               if (((word >> 14) & 0x1) == 0)
12390                                                 {
12391                                                   /* 33222222222211111111110000000000
12392                                                      10987654321098765432109876543210
12393                                                      xxxxxxxxxx01100xxxxxx0xx011100xx
12394                                                      uzp1.  */
12395                                                   return 256;
12396                                                 }
12397                                               else
12398                                                 {
12399                                                   /* 33222222222211111111110000000000
12400                                                      10987654321098765432109876543210
12401                                                      xxxxxxxxxx01101xxxxxx0xx011100xx
12402                                                      uzp2.  */
12403                                                   return 259;
12404                                                 }
12405                                             }
12406                                           else
12407                                             {
12408                                               if (((word >> 14) & 0x1) == 0)
12409                                                 {
12410                                                   /* 33222222222211111111110000000000
12411                                                      10987654321098765432109876543210
12412                                                      xxxxxxxxxx01110xxxxxx0xx011100xx
12413                                                      zip1.  */
12414                                                   return 258;
12415                                                 }
12416                                               else
12417                                                 {
12418                                                   /* 33222222222211111111110000000000
12419                                                      10987654321098765432109876543210
12420                                                      xxxxxxxxxx01111xxxxxx0xx011100xx
12421                                                      zip2.  */
12422                                                   return 261;
12423                                                 }
12424                                             }
12425                                         }
12426                                     }
12427                                 }
12428                               else
12429                                 {
12430                                   /* 33222222222211111111110000000000
12431                                      10987654321098765432109876543210
12432                                      xxxxxxxxxx0xxxxxxxxxx0xx011101xx
12433                                      ext.  */
12434                                   return 130;
12435                                 }
12436                             }
12437                           else
12438                             {
12439                               if (((word >> 15) & 0x1) == 0)
12440                                 {
12441                                   if (((word >> 22) & 0x1) == 0)
12442                                     {
12443                                       if (((word >> 29) & 0x1) == 0)
12444                                         {
12445                                           if (((word >> 11) & 0x1) == 0)
12446                                             {
12447                                               /* 33222222222211111111110000000000
12448                                                  10987654321098765432109876543210
12449                                                  xxxxxxxxxx10xxx0xxxxx00x011100xx
12450                                                  dup.  */
12451                                               return 147;
12452                                             }
12453                                           else
12454                                             {
12455                                               if (((word >> 12) & 0x1) == 0)
12456                                                 {
12457                                                   if (((word >> 13) & 0x1) == 0)
12458                                                     {
12459                                                       /* 33222222222211111111110000000000
12460                                                          10987654321098765432109876543210
12461                                                          xxxxxxxxxx1100x0xxxxx00x011100xx
12462                                                          dup.  */
12463                                                       return 148;
12464                                                     }
12465                                                   else
12466                                                     {
12467                                                       /* 33222222222211111111110000000000
12468                                                          10987654321098765432109876543210
12469                                                          xxxxxxxxxx1101x0xxxxx00x011100xx
12470                                                          smov.  */
12471                                                       return 149;
12472                                                     }
12473                                                 }
12474                                               else
12475                                                 {
12476                                                   if (((word >> 13) & 0x1) == 0)
12477                                                     {
12478                                                       /* 33222222222211111111110000000000
12479                                                          10987654321098765432109876543210
12480                                                          xxxxxxxxxx1110x0xxxxx00x011100xx
12481                                                          ins.  */
12482                                                       return 152;
12483                                                     }
12484                                                   else
12485                                                     {
12486                                                       /* 33222222222211111111110000000000
12487                                                          10987654321098765432109876543210
12488                                                          xxxxxxxxxx1111x0xxxxx00x011100xx
12489                                                          umov.  */
12490                                                       return 150;
12491                                                     }
12492                                                 }
12493                                             }
12494                                         }
12495                                       else
12496                                         {
12497                                           /* 33222222222211111111110000000000
12498                                              10987654321098765432109876543210
12499                                              xxxxxxxxxx1xxxx0xxxxx00x011101xx
12500                                              ins.  */
12501                                           return 154;
12502                                         }
12503                                     }
12504                                   else
12505                                     {
12506                                       if (((word >> 11) & 0x1) == 0)
12507                                         {
12508                                           if (((word >> 12) & 0x1) == 0)
12509                                             {
12510                                               if (((word >> 13) & 0x1) == 0)
12511                                                 {
12512                                                   if (((word >> 23) & 0x1) == 0)
12513                                                     {
12514                                                       if (((word >> 29) & 0x1) == 0)
12515                                                         {
12516                                                           /* 33222222222211111111110000000000
12517                                                              10987654321098765432109876543210
12518                                                              xxxxxxxxxx1000x0xxxxx010011100xx
12519                                                              fmaxnm.  */
12520                                                           return 286;
12521                                                         }
12522                                                       else
12523                                                         {
12524                                                           /* 33222222222211111111110000000000
12525                                                              10987654321098765432109876543210
12526                                                              xxxxxxxxxx1000x0xxxxx010011101xx
12527                                                              fmaxnmp.  */
12528                                                           return 337;
12529                                                         }
12530                                                     }
12531                                                   else
12532                                                     {
12533                                                       if (((word >> 29) & 0x1) == 0)
12534                                                         {
12535                                                           /* 33222222222211111111110000000000
12536                                                              10987654321098765432109876543210
12537                                                              xxxxxxxxxx1000x0xxxxx011011100xx
12538                                                              fminnm.  */
12539                                                           return 302;
12540                                                         }
12541                                                       else
12542                                                         {
12543                                                           /* 33222222222211111111110000000000
12544                                                              10987654321098765432109876543210
12545                                                              xxxxxxxxxx1000x0xxxxx011011101xx
12546                                                              fminnmp.  */
12547                                                           return 353;
12548                                                         }
12549                                                     }
12550                                                 }
12551                                               else
12552                                                 {
12553                                                   if (((word >> 23) & 0x1) == 0)
12554                                                     {
12555                                                       if (((word >> 29) & 0x1) == 0)
12556                                                         {
12557                                                           /* 33222222222211111111110000000000
12558                                                              10987654321098765432109876543210
12559                                                              xxxxxxxxxx1001x0xxxxx010011100xx
12560                                                              fcmeq.  */
12561                                                           return 294;
12562                                                         }
12563                                                       else
12564                                                         {
12565                                                           /* 33222222222211111111110000000000
12566                                                              10987654321098765432109876543210
12567                                                              xxxxxxxxxx1001x0xxxxx010011101xx
12568                                                              fcmge.  */
12569                                                           return 343;
12570                                                         }
12571                                                     }
12572                                                   else
12573                                                     {
12574                                                       /* 33222222222211111111110000000000
12575                                                          10987654321098765432109876543210
12576                                                          xxxxxxxxxx1001x0xxxxx01101110xxx
12577                                                          fcmgt.  */
12578                                                       return 357;
12579                                                     }
12580                                                 }
12581                                             }
12582                                           else
12583                                             {
12584                                               if (((word >> 13) & 0x1) == 0)
12585                                                 {
12586                                                   if (((word >> 23) & 0x1) == 0)
12587                                                     {
12588                                                       if (((word >> 29) & 0x1) == 0)
12589                                                         {
12590                                                           /* 33222222222211111111110000000000
12591                                                              10987654321098765432109876543210
12592                                                              xxxxxxxxxx1010x0xxxxx010011100xx
12593                                                              fadd.  */
12594                                                           return 290;
12595                                                         }
12596                                                       else
12597                                                         {
12598                                                           /* 33222222222211111111110000000000
12599                                                              10987654321098765432109876543210
12600                                                              xxxxxxxxxx1010x0xxxxx010011101xx
12601                                                              faddp.  */
12602                                                           return 339;
12603                                                         }
12604                                                     }
12605                                                   else
12606                                                     {
12607                                                       if (((word >> 29) & 0x1) == 0)
12608                                                         {
12609                                                           /* 33222222222211111111110000000000
12610                                                              10987654321098765432109876543210
12611                                                              xxxxxxxxxx1010x0xxxxx011011100xx
12612                                                              fsub.  */
12613                                                           return 306;
12614                                                         }
12615                                                       else
12616                                                         {
12617                                                           /* 33222222222211111111110000000000
12618                                                              10987654321098765432109876543210
12619                                                              xxxxxxxxxx1010x0xxxxx011011101xx
12620                                                              fabd.  */
12621                                                           return 355;
12622                                                         }
12623                                                     }
12624                                                 }
12625                                               else
12626                                                 {
12627                                                   if (((word >> 23) & 0x1) == 0)
12628                                                     {
12629                                                       if (((word >> 29) & 0x1) == 0)
12630                                                         {
12631                                                           /* 33222222222211111111110000000000
12632                                                              10987654321098765432109876543210
12633                                                              xxxxxxxxxx1011x0xxxxx010011100xx
12634                                                              fmax.  */
12635                                                           return 296;
12636                                                         }
12637                                                       else
12638                                                         {
12639                                                           /* 33222222222211111111110000000000
12640                                                              10987654321098765432109876543210
12641                                                              xxxxxxxxxx1011x0xxxxx010011101xx
12642                                                              fmaxp.  */
12643                                                           return 347;
12644                                                         }
12645                                                     }
12646                                                   else
12647                                                     {
12648                                                       if (((word >> 29) & 0x1) == 0)
12649                                                         {
12650                                                           /* 33222222222211111111110000000000
12651                                                              10987654321098765432109876543210
12652                                                              xxxxxxxxxx1011x0xxxxx011011100xx
12653                                                              fmin.  */
12654                                                           return 308;
12655                                                         }
12656                                                       else
12657                                                         {
12658                                                           /* 33222222222211111111110000000000
12659                                                              10987654321098765432109876543210
12660                                                              xxxxxxxxxx1011x0xxxxx011011101xx
12661                                                              fminp.  */
12662                                                           return 361;
12663                                                         }
12664                                                     }
12665                                                 }
12666                                             }
12667                                         }
12668                                       else
12669                                         {
12670                                           if (((word >> 12) & 0x1) == 0)
12671                                             {
12672                                               if (((word >> 13) & 0x1) == 0)
12673                                                 {
12674                                                   if (((word >> 23) & 0x1) == 0)
12675                                                     {
12676                                                       /* 33222222222211111111110000000000
12677                                                          10987654321098765432109876543210
12678                                                          xxxxxxxxxx1100x0xxxxx01001110xxx
12679                                                          fmla.  */
12680                                                       return 288;
12681                                                     }
12682                                                   else
12683                                                     {
12684                                                       /* 33222222222211111111110000000000
12685                                                          10987654321098765432109876543210
12686                                                          xxxxxxxxxx1100x0xxxxx01101110xxx
12687                                                          fmls.  */
12688                                                       return 304;
12689                                                     }
12690                                                 }
12691                                               else
12692                                                 {
12693                                                   if (((word >> 23) & 0x1) == 0)
12694                                                     {
12695                                                       /* 33222222222211111111110000000000
12696                                                          10987654321098765432109876543210
12697                                                          xxxxxxxxxx1101x0xxxxx01001110xxx
12698                                                          facge.  */
12699                                                       return 345;
12700                                                     }
12701                                                   else
12702                                                     {
12703                                                       /* 33222222222211111111110000000000
12704                                                          10987654321098765432109876543210
12705                                                          xxxxxxxxxx1101x0xxxxx01101110xxx
12706                                                          facgt.  */
12707                                                       return 359;
12708                                                     }
12709                                                 }
12710                                             }
12711                                           else
12712                                             {
12713                                               if (((word >> 13) & 0x1) == 0)
12714                                                 {
12715                                                   if (((word >> 29) & 0x1) == 0)
12716                                                     {
12717                                                       /* 33222222222211111111110000000000
12718                                                          10987654321098765432109876543210
12719                                                          xxxxxxxxxx1110x0xxxxx01x011100xx
12720                                                          fmulx.  */
12721                                                       return 292;
12722                                                     }
12723                                                   else
12724                                                     {
12725                                                       /* 33222222222211111111110000000000
12726                                                          10987654321098765432109876543210
12727                                                          xxxxxxxxxx1110x0xxxxx01x011101xx
12728                                                          fmul.  */
12729                                                       return 341;
12730                                                     }
12731                                                 }
12732                                               else
12733                                                 {
12734                                                   if (((word >> 23) & 0x1) == 0)
12735                                                     {
12736                                                       if (((word >> 29) & 0x1) == 0)
12737                                                         {
12738                                                           /* 33222222222211111111110000000000
12739                                                              10987654321098765432109876543210
12740                                                              xxxxxxxxxx1111x0xxxxx010011100xx
12741                                                              frecps.  */
12742                                                           return 298;
12743                                                         }
12744                                                       else
12745                                                         {
12746                                                           /* 33222222222211111111110000000000
12747                                                              10987654321098765432109876543210
12748                                                              xxxxxxxxxx1111x0xxxxx010011101xx
12749                                                              fdiv.  */
12750                                                           return 349;
12751                                                         }
12752                                                     }
12753                                                   else
12754                                                     {
12755                                                       /* 33222222222211111111110000000000
12756                                                          10987654321098765432109876543210
12757                                                          xxxxxxxxxx1111x0xxxxx01101110xxx
12758                                                          frsqrts.  */
12759                                                       return 310;
12760                                                     }
12761                                                 }
12762                                             }
12763                                         }
12764                                     }
12765                                 }
12766                               else
12767                                 {
12768                                   if (((word >> 13) & 0x1) == 0)
12769                                     {
12770                                       if (((word >> 14) & 0x1) == 0)
12771                                         {
12772                                           if (((word >> 11) & 0x1) == 0)
12773                                             {
12774                                               if (((word >> 12) & 0x1) == 0)
12775                                                 {
12776                                                   /* 33222222222211111111110000000000
12777                                                      10987654321098765432109876543210
12778                                                      xxxxxxxxxx100001xxxxx0xx01110xxx
12779                                                      sqrdmlah.  */
12780                                                   return 364;
12781                                                 }
12782                                               else
12783                                                 {
12784                                                   if (((word >> 29) & 0x1) == 0)
12785                                                     {
12786                                                       /* 33222222222211111111110000000000
12787                                                          10987654321098765432109876543210
12788                                                          xxxxxxxxxx101001xxxxx0xx011100xx
12789                                                          sdot.  */
12790                                                       return 1987;
12791                                                     }
12792                                                   else
12793                                                     {
12794                                                       /* 33222222222211111111110000000000
12795                                                          10987654321098765432109876543210
12796                                                          xxxxxxxxxx101001xxxxx0xx011101xx
12797                                                          udot.  */
12798                                                       return 1986;
12799                                                     }
12800                                                 }
12801                                             }
12802                                           else
12803                                             {
12804                                               /* 33222222222211111111110000000000
12805                                                  10987654321098765432109876543210
12806                                                  xxxxxxxxxx11x001xxxxx0xx01110xxx
12807                                                  sqrdmlsh.  */
12808                                               return 365;
12809                                             }
12810                                         }
12811                                       else
12812                                         {
12813                                           /* 33222222222211111111110000000000
12814                                              10987654321098765432109876543210
12815                                              xxxxxxxxxx1xx011xxxxx0xx01110xxx
12816                                              fcmla.  */
12817                                           return 366;
12818                                         }
12819                                     }
12820                                   else
12821                                     {
12822                                       /* 33222222222211111111110000000000
12823                                          10987654321098765432109876543210
12824                                          xxxxxxxxxx1xx1x1xxxxx0xx01110xxx
12825                                          fcadd.  */
12826                                       return 367;
12827                                     }
12828                                 }
12829                             }
12830                         }
12831                       else
12832                         {
12833                           if (((word >> 29) & 0x1) == 0)
12834                             {
12835                               if (((word >> 30) & 0x1) == 0)
12836                                 {
12837                                   if (((word >> 16) & 0x1) == 0)
12838                                     {
12839                                       if (((word >> 17) & 0x1) == 0)
12840                                         {
12841                                           /* 33222222222211111111110000000000
12842                                              10987654321098765432109876543210
12843                                              xxxxxxxxxxxxxxxx00xxx0xx0111100x
12844                                              fcvtzs.  */
12845                                           return 752;
12846                                         }
12847                                       else
12848                                         {
12849                                           /* 33222222222211111111110000000000
12850                                              10987654321098765432109876543210
12851                                              xxxxxxxxxxxxxxxx01xxx0xx0111100x
12852                                              scvtf.  */
12853                                           return 748;
12854                                         }
12855                                     }
12856                                   else
12857                                     {
12858                                       if (((word >> 17) & 0x1) == 0)
12859                                         {
12860                                           /* 33222222222211111111110000000000
12861                                              10987654321098765432109876543210
12862                                              xxxxxxxxxxxxxxxx10xxx0xx0111100x
12863                                              fcvtzu.  */
12864                                           return 754;
12865                                         }
12866                                       else
12867                                         {
12868                                           /* 33222222222211111111110000000000
12869                                              10987654321098765432109876543210
12870                                              xxxxxxxxxxxxxxxx11xxx0xx0111100x
12871                                              ucvtf.  */
12872                                           return 750;
12873                                         }
12874                                     }
12875                                 }
12876                               else
12877                                 {
12878                                   if (((word >> 10) & 0x1) == 0)
12879                                     {
12880                                       if (((word >> 12) & 0x1) == 0)
12881                                         {
12882                                           if (((word >> 13) & 0x1) == 0)
12883                                             {
12884                                               if (((word >> 14) & 0x1) == 0)
12885                                                 {
12886                                                   /* 33222222222211111111110000000000
12887                                                      10987654321098765432109876543210
12888                                                      xxxxxxxxxx0x000xxxxxx0xx0111101x
12889                                                      sha1c.  */
12890                                                   return 672;
12891                                                 }
12892                                               else
12893                                                 {
12894                                                   /* 33222222222211111111110000000000
12895                                                      10987654321098765432109876543210
12896                                                      xxxxxxxxxx0x001xxxxxx0xx0111101x
12897                                                      sha256h.  */
12898                                                   return 676;
12899                                                 }
12900                                             }
12901                                           else
12902                                             {
12903                                               if (((word >> 14) & 0x1) == 0)
12904                                                 {
12905                                                   /* 33222222222211111111110000000000
12906                                                      10987654321098765432109876543210
12907                                                      xxxxxxxxxx0x010xxxxxx0xx0111101x
12908                                                      sha1m.  */
12909                                                   return 674;
12910                                                 }
12911                                               else
12912                                                 {
12913                                                   /* 33222222222211111111110000000000
12914                                                      10987654321098765432109876543210
12915                                                      xxxxxxxxxx0x011xxxxxx0xx0111101x
12916                                                      sha256su1.  */
12917                                                   return 678;
12918                                                 }
12919                                             }
12920                                         }
12921                                       else
12922                                         {
12923                                           if (((word >> 13) & 0x1) == 0)
12924                                             {
12925                                               if (((word >> 14) & 0x1) == 0)
12926                                                 {
12927                                                   /* 33222222222211111111110000000000
12928                                                      10987654321098765432109876543210
12929                                                      xxxxxxxxxx0x100xxxxxx0xx0111101x
12930                                                      sha1p.  */
12931                                                   return 673;
12932                                                 }
12933                                               else
12934                                                 {
12935                                                   /* 33222222222211111111110000000000
12936                                                      10987654321098765432109876543210
12937                                                      xxxxxxxxxx0x101xxxxxx0xx0111101x
12938                                                      sha256h2.  */
12939                                                   return 677;
12940                                                 }
12941                                             }
12942                                           else
12943                                             {
12944                                               /* 33222222222211111111110000000000
12945                                                  10987654321098765432109876543210
12946                                                  xxxxxxxxxx0x11xxxxxxx0xx0111101x
12947                                                  sha1su0.  */
12948                                               return 675;
12949                                             }
12950                                         }
12951                                     }
12952                                   else
12953                                     {
12954                                       if (((word >> 11) & 0x1) == 0)
12955                                         {
12956                                           if (((word >> 13) & 0x1) == 0)
12957                                             {
12958                                               /* 33222222222211111111110000000000
12959                                                  10987654321098765432109876543210
12960                                                  xxxxxxxxxx10x0xxxxxxx0xx0111101x
12961                                                  dup.  */
12962                                               return 529;
12963                                             }
12964                                           else
12965                                             {
12966                                               /* 33222222222211111111110000000000
12967                                                  10987654321098765432109876543210
12968                                                  xxxxxxxxxx10x1xxxxxxx0xx0111101x
12969                                                  fcmeq.  */
12970                                               return 550;
12971                                             }
12972                                         }
12973                                       else
12974                                         {
12975                                           if (((word >> 13) & 0x1) == 0)
12976                                             {
12977                                               /* 33222222222211111111110000000000
12978                                                  10987654321098765432109876543210
12979                                                  xxxxxxxxxx11x0xxxxxxx0xx0111101x
12980                                                  fmulx.  */
12981                                               return 548;
12982                                             }
12983                                           else
12984                                             {
12985                                               if (((word >> 23) & 0x1) == 0)
12986                                                 {
12987                                                   /* 33222222222211111111110000000000
12988                                                      10987654321098765432109876543210
12989                                                      xxxxxxxxxx11x1xxxxxxx0x00111101x
12990                                                      frecps.  */
12991                                                   return 552;
12992                                                 }
12993                                               else
12994                                                 {
12995                                                   /* 33222222222211111111110000000000
12996                                                      10987654321098765432109876543210
12997                                                      xxxxxxxxxx11x1xxxxxxx0x10111101x
12998                                                      frsqrts.  */
12999                                                   return 554;
13000                                                 }
13001                                             }
13002                                         }
13003                                     }
13004                                 }
13005                             }
13006                           else
13007                             {
13008                               if (((word >> 11) & 0x1) == 0)
13009                                 {
13010                                   if (((word >> 12) & 0x1) == 0)
13011                                     {
13012                                       if (((word >> 13) & 0x1) == 0)
13013                                         {
13014                                           /* 33222222222211111111110000000000
13015                                              10987654321098765432109876543210
13016                                              xxxxxxxxxxx000xxxxxxx0xx011111xx
13017                                              sqrdmlah.  */
13018                                           return 582;
13019                                         }
13020                                       else
13021                                         {
13022                                           if (((word >> 23) & 0x1) == 0)
13023                                             {
13024                                               /* 33222222222211111111110000000000
13025                                                  10987654321098765432109876543210
13026                                                  xxxxxxxxxxx001xxxxxxx0x0011111xx
13027                                                  fcmge.  */
13028                                               return 567;
13029                                             }
13030                                           else
13031                                             {
13032                                               /* 33222222222211111111110000000000
13033                                                  10987654321098765432109876543210
13034                                                  xxxxxxxxxxx001xxxxxxx0x1011111xx
13035                                                  fcmgt.  */
13036                                               return 573;
13037                                             }
13038                                         }
13039                                     }
13040                                   else
13041                                     {
13042                                       /* 33222222222211111111110000000000
13043                                          10987654321098765432109876543210
13044                                          xxxxxxxxxxx01xxxxxxxx0xx011111xx
13045                                          fabd.  */
13046                                       return 571;
13047                                     }
13048                                 }
13049                               else
13050                                 {
13051                                   if (((word >> 13) & 0x1) == 0)
13052                                     {
13053                                       /* 33222222222211111111110000000000
13054                                          10987654321098765432109876543210
13055                                          xxxxxxxxxxx1x0xxxxxxx0xx011111xx
13056                                          sqrdmlsh.  */
13057                                       return 583;
13058                                     }
13059                                   else
13060                                     {
13061                                       if (((word >> 23) & 0x1) == 0)
13062                                         {
13063                                           /* 33222222222211111111110000000000
13064                                              10987654321098765432109876543210
13065                                              xxxxxxxxxxx1x1xxxxxxx0x0011111xx
13066                                              facge.  */
13067                                           return 569;
13068                                         }
13069                                       else
13070                                         {
13071                                           /* 33222222222211111111110000000000
13072                                              10987654321098765432109876543210
13073                                              xxxxxxxxxxx1x1xxxxxxx0x1011111xx
13074                                              facgt.  */
13075                                           return 575;
13076                                         }
13077                                     }
13078                                 }
13079                             }
13080                         }
13081                     }
13082                   else
13083                     {
13084                       if (((word >> 10) & 0x1) == 0)
13085                         {
13086                           if (((word >> 11) & 0x1) == 0)
13087                             {
13088                               if (((word >> 12) & 0x1) == 0)
13089                                 {
13090                                   if (((word >> 13) & 0x1) == 0)
13091                                     {
13092                                       if (((word >> 14) & 0x1) == 0)
13093                                         {
13094                                           if (((word >> 15) & 0x1) == 0)
13095                                             {
13096                                               if (((word >> 28) & 0x1) == 0)
13097                                                 {
13098                                                   if (((word >> 29) & 0x1) == 0)
13099                                                     {
13100                                                       if (((word >> 30) & 0x1) == 0)
13101                                                         {
13102                                                           /* 33222222222211111111110000000000
13103                                                              10987654321098765432109876543210
13104                                                              xxxxxxxxxx000000xxxxx1xx0111000x
13105                                                              saddl.  */
13106                                                           return 42;
13107                                                         }
13108                                                       else
13109                                                         {
13110                                                           /* 33222222222211111111110000000000
13111                                                              10987654321098765432109876543210
13112                                                              xxxxxxxxxx000000xxxxx1xx0111001x
13113                                                              saddl2.  */
13114                                                           return 43;
13115                                                         }
13116                                                     }
13117                                                   else
13118                                                     {
13119                                                       if (((word >> 30) & 0x1) == 0)
13120                                                         {
13121                                                           /* 33222222222211111111110000000000
13122                                                              10987654321098765432109876543210
13123                                                              xxxxxxxxxx000000xxxxx1xx0111010x
13124                                                              uaddl.  */
13125                                                           return 74;
13126                                                         }
13127                                                       else
13128                                                         {
13129                                                           /* 33222222222211111111110000000000
13130                                                              10987654321098765432109876543210
13131                                                              xxxxxxxxxx000000xxxxx1xx0111011x
13132                                                              uaddl2.  */
13133                                                           return 75;
13134                                                         }
13135                                                     }
13136                                                 }
13137                                               else
13138                                                 {
13139                                                   if (((word >> 16) & 0x1) == 0)
13140                                                     {
13141                                                       if (((word >> 17) & 0x1) == 0)
13142                                                         {
13143                                                           if (((word >> 18) & 0x1) == 0)
13144                                                             {
13145                                                               if (((word >> 19) & 0x1) == 0)
13146                                                                 {
13147                                                                   if (((word >> 20) & 0x1) == 0)
13148                                                                     {
13149                                                                       /* 33222222222211111111110000000000
13150                                                                          10987654321098765432109876543210
13151                                                                          xxxxxxxxxx000000000001xx01111xxx
13152                                                                          fcvtns.  */
13153                                                                       return 756;
13154                                                                     }
13155                                                                   else
13156                                                                     {
13157                                                                       /* 33222222222211111111110000000000
13158                                                                          10987654321098765432109876543210
13159                                                                          xxxxxxxxxx000000000011xx01111xxx
13160                                                                          fcvtms.  */
13161                                                                       return 776;
13162                                                                     }
13163                                                                 }
13164                                                               else
13165                                                                 {
13166                                                                   if (((word >> 20) & 0x1) == 0)
13167                                                                     {
13168                                                                       /* 33222222222211111111110000000000
13169                                                                          10987654321098765432109876543210
13170                                                                          xxxxxxxxxx000000000101xx01111xxx
13171                                                                          fcvtps.  */
13172                                                                       return 772;
13173                                                                     }
13174                                                                   else
13175                                                                     {
13176                                                                       /* 33222222222211111111110000000000
13177                                                                          10987654321098765432109876543210
13178                                                                          xxxxxxxxxx000000000111xx01111xxx
13179                                                                          fcvtzs.  */
13180                                                                       return 780;
13181                                                                     }
13182                                                                 }
13183                                                             }
13184                                                           else
13185                                                             {
13186                                                               /* 33222222222211111111110000000000
13187                                                                  10987654321098765432109876543210
13188                                                                  xxxxxxxxxx000000001xx1xx01111xxx
13189                                                                  fcvtas.  */
13190                                                               return 764;
13191                                                             }
13192                                                         }
13193                                                       else
13194                                                         {
13195                                                           if (((word >> 18) & 0x1) == 0)
13196                                                             {
13197                                                               /* 33222222222211111111110000000000
13198                                                                  10987654321098765432109876543210
13199                                                                  xxxxxxxxxx000000010xx1xx01111xxx
13200                                                                  scvtf.  */
13201                                                               return 760;
13202                                                             }
13203                                                           else
13204                                                             {
13205                                                               if (((word >> 19) & 0x1) == 0)
13206                                                                 {
13207                                                                   /* 33222222222211111111110000000000
13208                                                                      10987654321098765432109876543210
13209                                                                      xxxxxxxxxx0000000110x1xx01111xxx
13210                                                                      fmov.  */
13211                                                                   return 768;
13212                                                                 }
13213                                                               else
13214                                                                 {
13215                                                                   if (((word >> 20) & 0x1) == 0)
13216                                                                     {
13217                                                                       /* 33222222222211111111110000000000
13218                                                                          10987654321098765432109876543210
13219                                                                          xxxxxxxxxx000000011101xx01111xxx
13220                                                                          fmov.  */
13221                                                                       return 784;
13222                                                                     }
13223                                                                   else
13224                                                                     {
13225                                                                       /* 33222222222211111111110000000000
13226                                                                          10987654321098765432109876543210
13227                                                                          xxxxxxxxxx000000011111xx01111xxx
13228                                                                          fjcvtzs.  */
13229                                                                       return 786;
13230                                                                     }
13231                                                                 }
13232                                                             }
13233                                                         }
13234                                                     }
13235                                                   else
13236                                                     {
13237                                                       if (((word >> 17) & 0x1) == 0)
13238                                                         {
13239                                                           if (((word >> 18) & 0x1) == 0)
13240                                                             {
13241                                                               if (((word >> 19) & 0x1) == 0)
13242                                                                 {
13243                                                                   if (((word >> 20) & 0x1) == 0)
13244                                                                     {
13245                                                                       /* 33222222222211111111110000000000
13246                                                                          10987654321098765432109876543210
13247                                                                          xxxxxxxxxx000000100001xx01111xxx
13248                                                                          fcvtnu.  */
13249                                                                       return 758;
13250                                                                     }
13251                                                                   else
13252                                                                     {
13253                                                                       /* 33222222222211111111110000000000
13254                                                                          10987654321098765432109876543210
13255                                                                          xxxxxxxxxx000000100011xx01111xxx
13256                                                                          fcvtmu.  */
13257                                                                       return 778;
13258                                                                     }
13259                                                                 }
13260                                                               else
13261                                                                 {
13262                                                                   if (((word >> 20) & 0x1) == 0)
13263                                                                     {
13264                                                                       /* 33222222222211111111110000000000
13265                                                                          10987654321098765432109876543210
13266                                                                          xxxxxxxxxx000000100101xx01111xxx
13267                                                                          fcvtpu.  */
13268                                                                       return 774;
13269                                                                     }
13270                                                                   else
13271                                                                     {
13272                                                                       /* 33222222222211111111110000000000
13273                                                                          10987654321098765432109876543210
13274                                                                          xxxxxxxxxx000000100111xx01111xxx
13275                                                                          fcvtzu.  */
13276                                                                       return 782;
13277                                                                     }
13278                                                                 }
13279                                                             }
13280                                                           else
13281                                                             {
13282                                                               /* 33222222222211111111110000000000
13283                                                                  10987654321098765432109876543210
13284                                                                  xxxxxxxxxx000000101xx1xx01111xxx
13285                                                                  fcvtau.  */
13286                                                               return 766;
13287                                                             }
13288                                                         }
13289                                                       else
13290                                                         {
13291                                                           if (((word >> 18) & 0x1) == 0)
13292                                                             {
13293                                                               /* 33222222222211111111110000000000
13294                                                                  10987654321098765432109876543210
13295                                                                  xxxxxxxxxx000000110xx1xx01111xxx
13296                                                                  ucvtf.  */
13297                                                               return 762;
13298                                                             }
13299                                                           else
13300                                                             {
13301                                                               if (((word >> 19) & 0x1) == 0)
13302                                                                 {
13303                                                                   /* 33222222222211111111110000000000
13304                                                                      10987654321098765432109876543210
13305                                                                      xxxxxxxxxx0000001110x1xx01111xxx
13306                                                                      fmov.  */
13307                                                                   return 770;
13308                                                                 }
13309                                                               else
13310                                                                 {
13311                                                                   /* 33222222222211111111110000000000
13312                                                                      10987654321098765432109876543210
13313                                                                      xxxxxxxxxx0000001111x1xx01111xxx
13314                                                                      fmov.  */
13315                                                                   return 785;
13316                                                                 }
13317                                                             }
13318                                                         }
13319                                                     }
13320                                                 }
13321                                             }
13322                                           else
13323                                             {
13324                                               if (((word >> 29) & 0x1) == 0)
13325                                                 {
13326                                                   if (((word >> 30) & 0x1) == 0)
13327                                                     {
13328                                                       /* 33222222222211111111110000000000
13329                                                          10987654321098765432109876543210
13330                                                          xxxxxxxxxx000001xxxxx1xx0111x00x
13331                                                          smlal.  */
13332                                                       return 58;
13333                                                     }
13334                                                   else
13335                                                     {
13336                                                       /* 33222222222211111111110000000000
13337                                                          10987654321098765432109876543210
13338                                                          xxxxxxxxxx000001xxxxx1xx0111x01x
13339                                                          smlal2.  */
13340                                                       return 59;
13341                                                     }
13342                                                 }
13343                                               else
13344                                                 {
13345                                                   if (((word >> 30) & 0x1) == 0)
13346                                                     {
13347                                                       /* 33222222222211111111110000000000
13348                                                          10987654321098765432109876543210
13349                                                          xxxxxxxxxx000001xxxxx1xx0111x10x
13350                                                          umlal.  */
13351                                                       return 90;
13352                                                     }
13353                                                   else
13354                                                     {
13355                                                       /* 33222222222211111111110000000000
13356                                                          10987654321098765432109876543210
13357                                                          xxxxxxxxxx000001xxxxx1xx0111x11x
13358                                                          umlal2.  */
13359                                                       return 91;
13360                                                     }
13361                                                 }
13362                                             }
13363                                         }
13364                                       else
13365                                         {
13366                                           if (((word >> 28) & 0x1) == 0)
13367                                             {
13368                                               if (((word >> 15) & 0x1) == 0)
13369                                                 {
13370                                                   if (((word >> 29) & 0x1) == 0)
13371                                                     {
13372                                                       if (((word >> 30) & 0x1) == 0)
13373                                                         {
13374                                                           /* 33222222222211111111110000000000
13375                                                              10987654321098765432109876543210
13376                                                              xxxxxxxxxx000010xxxxx1xx0111000x
13377                                                              addhn.  */
13378                                                           return 50;
13379                                                         }
13380                                                       else
13381                                                         {
13382                                                           /* 33222222222211111111110000000000
13383                                                              10987654321098765432109876543210
13384                                                              xxxxxxxxxx000010xxxxx1xx0111001x
13385                                                              addhn2.  */
13386                                                           return 51;
13387                                                         }
13388                                                     }
13389                                                   else
13390                                                     {
13391                                                       if (((word >> 30) & 0x1) == 0)
13392                                                         {
13393                                                           /* 33222222222211111111110000000000
13394                                                              10987654321098765432109876543210
13395                                                              xxxxxxxxxx000010xxxxx1xx0111010x
13396                                                              raddhn.  */
13397                                                           return 82;
13398                                                         }
13399                                                       else
13400                                                         {
13401                                                           /* 33222222222211111111110000000000
13402                                                              10987654321098765432109876543210
13403                                                              xxxxxxxxxx000010xxxxx1xx0111011x
13404                                                              raddhn2.  */
13405                                                           return 83;
13406                                                         }
13407                                                     }
13408                                                 }
13409                                               else
13410                                                 {
13411                                                   if (((word >> 29) & 0x1) == 0)
13412                                                     {
13413                                                       if (((word >> 30) & 0x1) == 0)
13414                                                         {
13415                                                           /* 33222222222211111111110000000000
13416                                                              10987654321098765432109876543210
13417                                                              xxxxxxxxxx000011xxxxx1xx0111000x
13418                                                              smull.  */
13419                                                           return 66;
13420                                                         }
13421                                                       else
13422                                                         {
13423                                                           /* 33222222222211111111110000000000
13424                                                              10987654321098765432109876543210
13425                                                              xxxxxxxxxx000011xxxxx1xx0111001x
13426                                                              smull2.  */
13427                                                           return 67;
13428                                                         }
13429                                                     }
13430                                                   else
13431                                                     {
13432                                                       if (((word >> 30) & 0x1) == 0)
13433                                                         {
13434                                                           /* 33222222222211111111110000000000
13435                                                              10987654321098765432109876543210
13436                                                              xxxxxxxxxx000011xxxxx1xx0111010x
13437                                                              umull.  */
13438                                                           return 94;
13439                                                         }
13440                                                       else
13441                                                         {
13442                                                           /* 33222222222211111111110000000000
13443                                                              10987654321098765432109876543210
13444                                                              xxxxxxxxxx000011xxxxx1xx0111011x
13445                                                              umull2.  */
13446                                                           return 95;
13447                                                         }
13448                                                     }
13449                                                 }
13450                                             }
13451                                           else
13452                                             {
13453                                               if (((word >> 17) & 0x1) == 0)
13454                                                 {
13455                                                   if (((word >> 15) & 0x1) == 0)
13456                                                     {
13457                                                       if (((word >> 16) & 0x1) == 0)
13458                                                         {
13459                                                           if (((word >> 18) & 0x1) == 0)
13460                                                             {
13461                                                               /* 33222222222211111111110000000000
13462                                                                  10987654321098765432109876543210
13463                                                                  xxxxxxxxxx000010000xx1xx01111xxx
13464                                                                  fmov.  */
13465                                                               return 799;
13466                                                             }
13467                                                           else
13468                                                             {
13469                                                               /* 33222222222211111111110000000000
13470                                                                  10987654321098765432109876543210
13471                                                                  xxxxxxxxxx000010001xx1xx01111xxx
13472                                                                  frintn.  */
13473                                                               return 808;
13474                                                             }
13475                                                         }
13476                                                       else
13477                                                         {
13478                                                           if (((word >> 18) & 0x1) == 0)
13479                                                             {
13480                                                               /* 33222222222211111111110000000000
13481                                                                  10987654321098765432109876543210
13482                                                                  xxxxxxxxxx000010100xx1xx01111xxx
13483                                                                  fneg.  */
13484                                                               return 803;
13485                                                             }
13486                                                           else
13487                                                             {
13488                                                               /* 33222222222211111111110000000000
13489                                                                  10987654321098765432109876543210
13490                                                                  xxxxxxxxxx000010101xx1xx01111xxx
13491                                                                  frintm.  */
13492                                                               return 812;
13493                                                             }
13494                                                         }
13495                                                     }
13496                                                   else
13497                                                     {
13498                                                       if (((word >> 16) & 0x1) == 0)
13499                                                         {
13500                                                           if (((word >> 18) & 0x1) == 0)
13501                                                             {
13502                                                               /* 33222222222211111111110000000000
13503                                                                  10987654321098765432109876543210
13504                                                                  xxxxxxxxxx000011000xx1xx01111xxx
13505                                                                  fabs.  */
13506                                                               return 801;
13507                                                             }
13508                                                           else
13509                                                             {
13510                                                               /* 33222222222211111111110000000000
13511                                                                  10987654321098765432109876543210
13512                                                                  xxxxxxxxxx000011001xx1xx01111xxx
13513                                                                  frintp.  */
13514                                                               return 810;
13515                                                             }
13516                                                         }
13517                                                       else
13518                                                         {
13519                                                           if (((word >> 18) & 0x1) == 0)
13520                                                             {
13521                                                               /* 33222222222211111111110000000000
13522                                                                  10987654321098765432109876543210
13523                                                                  xxxxxxxxxx000011100xx1xx01111xxx
13524                                                                  fsqrt.  */
13525                                                               return 805;
13526                                                             }
13527                                                           else
13528                                                             {
13529                                                               /* 33222222222211111111110000000000
13530                                                                  10987654321098765432109876543210
13531                                                                  xxxxxxxxxx000011101xx1xx01111xxx
13532                                                                  frintz.  */
13533                                                               return 814;
13534                                                             }
13535                                                         }
13536                                                     }
13537                                                 }
13538                                               else
13539                                                 {
13540                                                   if (((word >> 18) & 0x1) == 0)
13541                                                     {
13542                                                       /* 33222222222211111111110000000000
13543                                                          10987654321098765432109876543210
13544                                                          xxxxxxxxxx00001xx10xx1xx01111xxx
13545                                                          fcvt.  */
13546                                                       return 807;
13547                                                     }
13548                                                   else
13549                                                     {
13550                                                       if (((word >> 15) & 0x1) == 0)
13551                                                         {
13552                                                           if (((word >> 16) & 0x1) == 0)
13553                                                             {
13554                                                               /* 33222222222211111111110000000000
13555                                                                  10987654321098765432109876543210
13556                                                                  xxxxxxxxxx000010011xx1xx01111xxx
13557                                                                  frinta.  */
13558                                                               return 816;
13559                                                             }
13560                                                           else
13561                                                             {
13562                                                               /* 33222222222211111111110000000000
13563                                                                  10987654321098765432109876543210
13564                                                                  xxxxxxxxxx000010111xx1xx01111xxx
13565                                                                  frintx.  */
13566                                                               return 818;
13567                                                             }
13568                                                         }
13569                                                       else
13570                                                         {
13571                                                           /* 33222222222211111111110000000000
13572                                                              10987654321098765432109876543210
13573                                                              xxxxxxxxxx000011x11xx1xx01111xxx
13574                                                              frinti.  */
13575                                                           return 820;
13576                                                         }
13577                                                     }
13578                                                 }
13579                                             }
13580                                         }
13581                                     }
13582                                   else
13583                                     {
13584                                       if (((word >> 14) & 0x1) == 0)
13585                                         {
13586                                           if (((word >> 15) & 0x1) == 0)
13587                                             {
13588                                               if (((word >> 28) & 0x1) == 0)
13589                                                 {
13590                                                   if (((word >> 29) & 0x1) == 0)
13591                                                     {
13592                                                       if (((word >> 30) & 0x1) == 0)
13593                                                         {
13594                                                           /* 33222222222211111111110000000000
13595                                                              10987654321098765432109876543210
13596                                                              xxxxxxxxxx000100xxxxx1xx0111000x
13597                                                              ssubl.  */
13598                                                           return 46;
13599                                                         }
13600                                                       else
13601                                                         {
13602                                                           /* 33222222222211111111110000000000
13603                                                              10987654321098765432109876543210
13604                                                              xxxxxxxxxx000100xxxxx1xx0111001x
13605                                                              ssubl2.  */
13606                                                           return 47;
13607                                                         }
13608                                                     }
13609                                                   else
13610                                                     {
13611                                                       if (((word >> 30) & 0x1) == 0)
13612                                                         {
13613                                                           /* 33222222222211111111110000000000
13614                                                              10987654321098765432109876543210
13615                                                              xxxxxxxxxx000100xxxxx1xx0111010x
13616                                                              usubl.  */
13617                                                           return 78;
13618                                                         }
13619                                                       else
13620                                                         {
13621                                                           /* 33222222222211111111110000000000
13622                                                              10987654321098765432109876543210
13623                                                              xxxxxxxxxx000100xxxxx1xx0111011x
13624                                                              usubl2.  */
13625                                                           return 79;
13626                                                         }
13627                                                     }
13628                                                 }
13629                                               else
13630                                                 {
13631                                                   if (((word >> 3) & 0x1) == 0)
13632                                                     {
13633                                                       if (((word >> 4) & 0x1) == 0)
13634                                                         {
13635                                                           /* 33222222222211111111110000000000
13636                                                              10987654321098765432109876543210
13637                                                              xxx00xxxxx000100xxxxx1xx01111xxx
13638                                                              fcmp.  */
13639                                                           return 791;
13640                                                         }
13641                                                       else
13642                                                         {
13643                                                           /* 33222222222211111111110000000000
13644                                                              10987654321098765432109876543210
13645                                                              xxx01xxxxx000100xxxxx1xx01111xxx
13646                                                              fcmpe.  */
13647                                                           return 793;
13648                                                         }
13649                                                     }
13650                                                   else
13651                                                     {
13652                                                       if (((word >> 4) & 0x1) == 0)
13653                                                         {
13654                                                           /* 33222222222211111111110000000000
13655                                                              10987654321098765432109876543210
13656                                                              xxx10xxxxx000100xxxxx1xx01111xxx
13657                                                              fcmp.  */
13658                                                           return 795;
13659                                                         }
13660                                                       else
13661                                                         {
13662                                                           /* 33222222222211111111110000000000
13663                                                              10987654321098765432109876543210
13664                                                              xxx11xxxxx000100xxxxx1xx01111xxx
13665                                                              fcmpe.  */
13666                                                           return 797;
13667                                                         }
13668                                                     }
13669                                                 }
13670                                             }
13671                                           else
13672                                             {
13673                                               if (((word >> 29) & 0x1) == 0)
13674                                                 {
13675                                                   if (((word >> 30) & 0x1) == 0)
13676                                                     {
13677                                                       /* 33222222222211111111110000000000
13678                                                          10987654321098765432109876543210
13679                                                          xxxxxxxxxx000101xxxxx1xx0111x00x
13680                                                          smlsl.  */
13681                                                       return 62;
13682                                                     }
13683                                                   else
13684                                                     {
13685                                                       /* 33222222222211111111110000000000
13686                                                          10987654321098765432109876543210
13687                                                          xxxxxxxxxx000101xxxxx1xx0111x01x
13688                                                          smlsl2.  */
13689                                                       return 63;
13690                                                     }
13691                                                 }
13692                                               else
13693                                                 {
13694                                                   if (((word >> 30) & 0x1) == 0)
13695                                                     {
13696                                                       /* 33222222222211111111110000000000
13697                                                          10987654321098765432109876543210
13698                                                          xxxxxxxxxx000101xxxxx1xx0111x10x
13699                                                          umlsl.  */
13700                                                       return 92;
13701                                                     }
13702                                                   else
13703                                                     {
13704                                                       /* 33222222222211111111110000000000
13705                                                          10987654321098765432109876543210
13706                                                          xxxxxxxxxx000101xxxxx1xx0111x11x
13707                                                          umlsl2.  */
13708                                                       return 93;
13709                                                     }
13710                                                 }
13711                                             }
13712                                         }
13713                                       else
13714                                         {
13715                                           if (((word >> 15) & 0x1) == 0)
13716                                             {
13717                                               if (((word >> 29) & 0x1) == 0)
13718                                                 {
13719                                                   if (((word >> 30) & 0x1) == 0)
13720                                                     {
13721                                                       /* 33222222222211111111110000000000
13722                                                          10987654321098765432109876543210
13723                                                          xxxxxxxxxx000110xxxxx1xx0111x00x
13724                                                          subhn.  */
13725                                                       return 54;
13726                                                     }
13727                                                   else
13728                                                     {
13729                                                       /* 33222222222211111111110000000000
13730                                                          10987654321098765432109876543210
13731                                                          xxxxxxxxxx000110xxxxx1xx0111x01x
13732                                                          subhn2.  */
13733                                                       return 55;
13734                                                     }
13735                                                 }
13736                                               else
13737                                                 {
13738                                                   if (((word >> 30) & 0x1) == 0)
13739                                                     {
13740                                                       /* 33222222222211111111110000000000
13741                                                          10987654321098765432109876543210
13742                                                          xxxxxxxxxx000110xxxxx1xx0111x10x
13743                                                          rsubhn.  */
13744                                                       return 86;
13745                                                     }
13746                                                   else
13747                                                     {
13748                                                       /* 33222222222211111111110000000000
13749                                                          10987654321098765432109876543210
13750                                                          xxxxxxxxxx000110xxxxx1xx0111x11x
13751                                                          rsubhn2.  */
13752                                                       return 87;
13753                                                     }
13754                                                 }
13755                                             }
13756                                           else
13757                                             {
13758                                               if (((word >> 22) & 0x1) == 0)
13759                                                 {
13760                                                   if (((word >> 30) & 0x1) == 0)
13761                                                     {
13762                                                       /* 33222222222211111111110000000000
13763                                                          10987654321098765432109876543210
13764                                                          xxxxxxxxxx000111xxxxx10x0111xx0x
13765                                                          pmull.  */
13766                                                       return 70;
13767                                                     }
13768                                                   else
13769                                                     {
13770                                                       /* 33222222222211111111110000000000
13771                                                          10987654321098765432109876543210
13772                                                          xxxxxxxxxx000111xxxxx10x0111xx1x
13773                                                          pmull2.  */
13774                                                       return 72;
13775                                                     }
13776                                                 }
13777                                               else
13778                                                 {
13779                                                   if (((word >> 30) & 0x1) == 0)
13780                                                     {
13781                                                       /* 33222222222211111111110000000000
13782                                                          10987654321098765432109876543210
13783                                                          xxxxxxxxxx000111xxxxx11x0111xx0x
13784                                                          pmull.  */
13785                                                       return 71;
13786                                                     }
13787                                                   else
13788                                                     {
13789                                                       /* 33222222222211111111110000000000
13790                                                          10987654321098765432109876543210
13791                                                          xxxxxxxxxx000111xxxxx11x0111xx1x
13792                                                          pmull2.  */
13793                                                       return 73;
13794                                                     }
13795                                                 }
13796                                             }
13797                                         }
13798                                     }
13799                                 }
13800                               else
13801                                 {
13802                                   if (((word >> 28) & 0x1) == 0)
13803                                     {
13804                                       if (((word >> 13) & 0x1) == 0)
13805                                         {
13806                                           if (((word >> 14) & 0x1) == 0)
13807                                             {
13808                                               if (((word >> 15) & 0x1) == 0)
13809                                                 {
13810                                                   if (((word >> 29) & 0x1) == 0)
13811                                                     {
13812                                                       if (((word >> 30) & 0x1) == 0)
13813                                                         {
13814                                                           /* 33222222222211111111110000000000
13815                                                              10987654321098765432109876543210
13816                                                              xxxxxxxxxx001000xxxxx1xx0111000x
13817                                                              saddw.  */
13818                                                           return 44;
13819                                                         }
13820                                                       else
13821                                                         {
13822                                                           /* 33222222222211111111110000000000
13823                                                              10987654321098765432109876543210
13824                                                              xxxxxxxxxx001000xxxxx1xx0111001x
13825                                                              saddw2.  */
13826                                                           return 45;
13827                                                         }
13828                                                     }
13829                                                   else
13830                                                     {
13831                                                       if (((word >> 30) & 0x1) == 0)
13832                                                         {
13833                                                           /* 33222222222211111111110000000000
13834                                                              10987654321098765432109876543210
13835                                                              xxxxxxxxxx001000xxxxx1xx0111010x
13836                                                              uaddw.  */
13837                                                           return 76;
13838                                                         }
13839                                                       else
13840                                                         {
13841                                                           /* 33222222222211111111110000000000
13842                                                              10987654321098765432109876543210
13843                                                              xxxxxxxxxx001000xxxxx1xx0111011x
13844                                                              uaddw2.  */
13845                                                           return 77;
13846                                                         }
13847                                                     }
13848                                                 }
13849                                               else
13850                                                 {
13851                                                   if (((word >> 30) & 0x1) == 0)
13852                                                     {
13853                                                       /* 33222222222211111111110000000000
13854                                                          10987654321098765432109876543210
13855                                                          xxxxxxxxxx001001xxxxx1xx01110x0x
13856                                                          sqdmlal.  */
13857                                                       return 60;
13858                                                     }
13859                                                   else
13860                                                     {
13861                                                       /* 33222222222211111111110000000000
13862                                                          10987654321098765432109876543210
13863                                                          xxxxxxxxxx001001xxxxx1xx01110x1x
13864                                                          sqdmlal2.  */
13865                                                       return 61;
13866                                                     }
13867                                                 }
13868                                             }
13869                                           else
13870                                             {
13871                                               if (((word >> 15) & 0x1) == 0)
13872                                                 {
13873                                                   if (((word >> 29) & 0x1) == 0)
13874                                                     {
13875                                                       if (((word >> 30) & 0x1) == 0)
13876                                                         {
13877                                                           /* 33222222222211111111110000000000
13878                                                              10987654321098765432109876543210
13879                                                              xxxxxxxxxx001010xxxxx1xx0111000x
13880                                                              sabal.  */
13881                                                           return 52;
13882                                                         }
13883                                                       else
13884                                                         {
13885                                                           /* 33222222222211111111110000000000
13886                                                              10987654321098765432109876543210
13887                                                              xxxxxxxxxx001010xxxxx1xx0111001x
13888                                                              sabal2.  */
13889                                                           return 53;
13890                                                         }
13891                                                     }
13892                                                   else
13893                                                     {
13894                                                       if (((word >> 30) & 0x1) == 0)
13895                                                         {
13896                                                           /* 33222222222211111111110000000000
13897                                                              10987654321098765432109876543210
13898                                                              xxxxxxxxxx001010xxxxx1xx0111010x
13899                                                              uabal.  */
13900                                                           return 84;
13901                                                         }
13902                                                       else
13903                                                         {
13904                                                           /* 33222222222211111111110000000000
13905                                                              10987654321098765432109876543210
13906                                                              xxxxxxxxxx001010xxxxx1xx0111011x
13907                                                              uabal2.  */
13908                                                           return 85;
13909                                                         }
13910                                                     }
13911                                                 }
13912                                               else
13913                                                 {
13914                                                   if (((word >> 30) & 0x1) == 0)
13915                                                     {
13916                                                       /* 33222222222211111111110000000000
13917                                                          10987654321098765432109876543210
13918                                                          xxxxxxxxxx001011xxxxx1xx01110x0x
13919                                                          sqdmull.  */
13920                                                       return 68;
13921                                                     }
13922                                                   else
13923                                                     {
13924                                                       /* 33222222222211111111110000000000
13925                                                          10987654321098765432109876543210
13926                                                          xxxxxxxxxx001011xxxxx1xx01110x1x
13927                                                          sqdmull2.  */
13928                                                       return 69;
13929                                                     }
13930                                                 }
13931                                             }
13932                                         }
13933                                       else
13934                                         {
13935                                           if (((word >> 14) & 0x1) == 0)
13936                                             {
13937                                               if (((word >> 15) & 0x1) == 0)
13938                                                 {
13939                                                   if (((word >> 29) & 0x1) == 0)
13940                                                     {
13941                                                       if (((word >> 30) & 0x1) == 0)
13942                                                         {
13943                                                           /* 33222222222211111111110000000000
13944                                                              10987654321098765432109876543210
13945                                                              xxxxxxxxxx001100xxxxx1xx0111000x
13946                                                              ssubw.  */
13947                                                           return 48;
13948                                                         }
13949                                                       else
13950                                                         {
13951                                                           /* 33222222222211111111110000000000
13952                                                              10987654321098765432109876543210
13953                                                              xxxxxxxxxx001100xxxxx1xx0111001x
13954                                                              ssubw2.  */
13955                                                           return 49;
13956                                                         }
13957                                                     }
13958                                                   else
13959                                                     {
13960                                                       if (((word >> 30) & 0x1) == 0)
13961                                                         {
13962                                                           /* 33222222222211111111110000000000
13963                                                              10987654321098765432109876543210
13964                                                              xxxxxxxxxx001100xxxxx1xx0111010x
13965                                                              usubw.  */
13966                                                           return 80;
13967                                                         }
13968                                                       else
13969                                                         {
13970                                                           /* 33222222222211111111110000000000
13971                                                              10987654321098765432109876543210
13972                                                              xxxxxxxxxx001100xxxxx1xx0111011x
13973                                                              usubw2.  */
13974                                                           return 81;
13975                                                         }
13976                                                     }
13977                                                 }
13978                                               else
13979                                                 {
13980                                                   if (((word >> 30) & 0x1) == 0)
13981                                                     {
13982                                                       /* 33222222222211111111110000000000
13983                                                          10987654321098765432109876543210
13984                                                          xxxxxxxxxx001101xxxxx1xx01110x0x
13985                                                          sqdmlsl.  */
13986                                                       return 64;
13987                                                     }
13988                                                   else
13989                                                     {
13990                                                       /* 33222222222211111111110000000000
13991                                                          10987654321098765432109876543210
13992                                                          xxxxxxxxxx001101xxxxx1xx01110x1x
13993                                                          sqdmlsl2.  */
13994                                                       return 65;
13995                                                     }
13996                                                 }
13997                                             }
13998                                           else
13999                                             {
14000                                               if (((word >> 29) & 0x1) == 0)
14001                                                 {
14002                                                   if (((word >> 30) & 0x1) == 0)
14003                                                     {
14004                                                       /* 33222222222211111111110000000000
14005                                                          10987654321098765432109876543210
14006                                                          xxxxxxxxxx00111xxxxxx1xx0111000x
14007                                                          sabdl.  */
14008                                                       return 56;
14009                                                     }
14010                                                   else
14011                                                     {
14012                                                       /* 33222222222211111111110000000000
14013                                                          10987654321098765432109876543210
14014                                                          xxxxxxxxxx00111xxxxxx1xx0111001x
14015                                                          sabdl2.  */
14016                                                       return 57;
14017                                                     }
14018                                                 }
14019                                               else
14020                                                 {
14021                                                   if (((word >> 30) & 0x1) == 0)
14022                                                     {
14023                                                       /* 33222222222211111111110000000000
14024                                                          10987654321098765432109876543210
14025                                                          xxxxxxxxxx00111xxxxxx1xx0111010x
14026                                                          uabdl.  */
14027                                                       return 88;
14028                                                     }
14029                                                   else
14030                                                     {
14031                                                       /* 33222222222211111111110000000000
14032                                                          10987654321098765432109876543210
14033                                                          xxxxxxxxxx00111xxxxxx1xx0111011x
14034                                                          uabdl2.  */
14035                                                       return 89;
14036                                                     }
14037                                                 }
14038                                             }
14039                                         }
14040                                     }
14041                                   else
14042                                     {
14043                                       if (((word >> 30) & 0x1) == 0)
14044                                         {
14045                                           /* 33222222222211111111110000000000
14046                                              10987654321098765432109876543210
14047                                              xxxxxxxxxx001xxxxxxxx1xx01111x0x
14048                                              fmov.  */
14049                                           return 848;
14050                                         }
14051                                       else
14052                                         {
14053                                           if (((word >> 13) & 0x1) == 0)
14054                                             {
14055                                               if (((word >> 14) & 0x1) == 0)
14056                                                 {
14057                                                   /* 33222222222211111111110000000000
14058                                                      10987654321098765432109876543210
14059                                                      xxxxxxxxxx00100xxxxxx1xx01111x1x
14060                                                      sqdmlal.  */
14061                                                   return 416;
14062                                                 }
14063                                               else
14064                                                 {
14065                                                   /* 33222222222211111111110000000000
14066                                                      10987654321098765432109876543210
14067                                                      xxxxxxxxxx00101xxxxxx1xx01111x1x
14068                                                      sqdmull.  */
14069                                                   return 418;
14070                                                 }
14071                                             }
14072                                           else
14073                                             {
14074                                               /* 33222222222211111111110000000000
14075                                                  10987654321098765432109876543210
14076                                                  xxxxxxxxxx0011xxxxxxx1xx01111x1x
14077                                                  sqdmlsl.  */
14078                                               return 417;
14079                                             }
14080                                         }
14081                                     }
14082                                 }
14083                             }
14084                           else
14085                             {
14086                               if (((word >> 12) & 0x1) == 0)
14087                                 {
14088                                   if (((word >> 13) & 0x1) == 0)
14089                                     {
14090                                       if (((word >> 14) & 0x1) == 0)
14091                                         {
14092                                           if (((word >> 15) & 0x1) == 0)
14093                                             {
14094                                               if (((word >> 28) & 0x1) == 0)
14095                                                 {
14096                                                   if (((word >> 29) & 0x1) == 0)
14097                                                     {
14098                                                       /* 33222222222211111111110000000000
14099                                                          10987654321098765432109876543210
14100                                                          xxxxxxxxxx010000xxxxx1xx011100xx
14101                                                          rev64.  */
14102                                                       return 156;
14103                                                     }
14104                                                   else
14105                                                     {
14106                                                       /* 33222222222211111111110000000000
14107                                                          10987654321098765432109876543210
14108                                                          xxxxxxxxxx010000xxxxx1xx011101xx
14109                                                          rev32.  */
14110                                                       return 207;
14111                                                     }
14112                                                 }
14113                                               else
14114                                                 {
14115                                                   if (((word >> 30) & 0x1) == 0)
14116                                                     {
14117                                                       /* 33222222222211111111110000000000
14118                                                          10987654321098765432109876543210
14119                                                          xxxxxxxxxx010000xxxxx1xx01111x0x
14120                                                          fmul.  */
14121                                                       return 822;
14122                                                     }
14123                                                   else
14124                                                     {
14125                                                       /* 33222222222211111111110000000000
14126                                                          10987654321098765432109876543210
14127                                                          xxxxxxxxxx010000xxxxx1xx01111x1x
14128                                                          sha1h.  */
14129                                                       return 669;
14130                                                     }
14131                                                 }
14132                                             }
14133                                           else
14134                                             {
14135                                               if (((word >> 28) & 0x1) == 0)
14136                                                 {
14137                                                   if (((word >> 16) & 0x1) == 0)
14138                                                     {
14139                                                       if (((word >> 29) & 0x1) == 0)
14140                                                         {
14141                                                           /* 33222222222211111111110000000000
14142                                                              10987654321098765432109876543210
14143                                                              xxxxxxxxxx0100010xxxx1xx011100xx
14144                                                              cmgt.  */
14145                                                           return 164;
14146                                                         }
14147                                                       else
14148                                                         {
14149                                                           /* 33222222222211111111110000000000
14150                                                              10987654321098765432109876543210
14151                                                              xxxxxxxxxx0100010xxxx1xx011101xx
14152                                                              cmge.  */
14153                                                           return 213;
14154                                                         }
14155                                                     }
14156                                                   else
14157                                                     {
14158                                                       if (((word >> 19) & 0x1) == 0)
14159                                                         {
14160                                                           if (((word >> 23) & 0x1) == 0)
14161                                                             {
14162                                                               if (((word >> 29) & 0x1) == 0)
14163                                                                 {
14164                                                                   /* 33222222222211111111110000000000
14165                                                                      10987654321098765432109876543210
14166                                                                      xxxxxxxxxx0100011xx0x1x0011100xx
14167                                                                      frintn.  */
14168                                                                   return 176;
14169                                                                 }
14170                                                               else
14171                                                                 {
14172                                                                   /* 33222222222211111111110000000000
14173                                                                      10987654321098765432109876543210
14174                                                                      xxxxxxxxxx0100011xx0x1x0011101xx
14175                                                                      frinta.  */
14176                                                                   return 224;
14177                                                                 }
14178                                                             }
14179                                                           else
14180                                                             {
14181                                                               /* 33222222222211111111110000000000
14182                                                                  10987654321098765432109876543210
14183                                                                  xxxxxxxxxx0100011xx0x1x101110xxx
14184                                                                  frintp.  */
14185                                                               return 196;
14186                                                             }
14187                                                         }
14188                                                       else
14189                                                         {
14190                                                           if (((word >> 23) & 0x1) == 0)
14191                                                             {
14192                                                               if (((word >> 29) & 0x1) == 0)
14193                                                                 {
14194                                                                   /* 33222222222211111111110000000000
14195                                                                      10987654321098765432109876543210
14196                                                                      xxxxxxxxxx0100011xx1x1x0011100xx
14197                                                                      frintn.  */
14198                                                                   return 177;
14199                                                                 }
14200                                                               else
14201                                                                 {
14202                                                                   /* 33222222222211111111110000000000
14203                                                                      10987654321098765432109876543210
14204                                                                      xxxxxxxxxx0100011xx1x1x0011101xx
14205                                                                      frinta.  */
14206                                                                   return 225;
14207                                                                 }
14208                                                             }
14209                                                           else
14210                                                             {
14211                                                               /* 33222222222211111111110000000000
14212                                                                  10987654321098765432109876543210
14213                                                                  xxxxxxxxxx0100011xx1x1x101110xxx
14214                                                                  frintp.  */
14215                                                               return 197;
14216                                                             }
14217                                                         }
14218                                                     }
14219                                                 }
14220                                               else
14221                                                 {
14222                                                   if (((word >> 29) & 0x1) == 0)
14223                                                     {
14224                                                       if (((word >> 30) & 0x1) == 0)
14225                                                         {
14226                                                           /* 33222222222211111111110000000000
14227                                                              10987654321098765432109876543210
14228                                                              xxxxxxxxxx010001xxxxx1xx0111100x
14229                                                              fnmul.  */
14230                                                           return 838;
14231                                                         }
14232                                                       else
14233                                                         {
14234                                                           /* 33222222222211111111110000000000
14235                                                              10987654321098765432109876543210
14236                                                              xxxxxxxxxx010001xxxxx1xx0111101x
14237                                                              cmgt.  */
14238                                                           return 476;
14239                                                         }
14240                                                     }
14241                                                   else
14242                                                     {
14243                                                       /* 33222222222211111111110000000000
14244                                                          10987654321098765432109876543210
14245                                                          xxxxxxxxxx010001xxxxx1xx011111xx
14246                                                          cmge.  */
14247                                                       return 505;
14248                                                     }
14249                                                 }
14250                                             }
14251                                         }
14252                                       else
14253                                         {
14254                                           if (((word >> 15) & 0x1) == 0)
14255                                             {
14256                                               if (((word >> 28) & 0x1) == 0)
14257                                                 {
14258                                                   if (((word >> 16) & 0x1) == 0)
14259                                                     {
14260                                                       if (((word >> 19) & 0x1) == 0)
14261                                                         {
14262                                                           if (((word >> 29) & 0x1) == 0)
14263                                                             {
14264                                                               /* 33222222222211111111110000000000
14265                                                                  10987654321098765432109876543210
14266                                                                  xxxxxxxxxx0100100xx0x1xx011100xx
14267                                                                  cls.  */
14268                                                               return 160;
14269                                                             }
14270                                                           else
14271                                                             {
14272                                                               /* 33222222222211111111110000000000
14273                                                                  10987654321098765432109876543210
14274                                                                  xxxxxxxxxx0100100xx0x1xx011101xx
14275                                                                  clz.  */
14276                                                               return 210;
14277                                                             }
14278                                                         }
14279                                                       else
14280                                                         {
14281                                                           /* 33222222222211111111110000000000
14282                                                              10987654321098765432109876543210
14283                                                              xxxxxxxxxx0100100xx1x1xx01110xxx
14284                                                              aese.  */
14285                                                           return 665;
14286                                                         }
14287                                                     }
14288                                                   else
14289                                                     {
14290                                                       if (((word >> 29) & 0x1) == 0)
14291                                                         {
14292                                                           if (((word >> 30) & 0x1) == 0)
14293                                                             {
14294                                                               /* 33222222222211111111110000000000
14295                                                                  10987654321098765432109876543210
14296                                                                  xxxxxxxxxx0100101xxxx1xx0111000x
14297                                                                  sqxtn.  */
14298                                                               return 170;
14299                                                             }
14300                                                           else
14301                                                             {
14302                                                               /* 33222222222211111111110000000000
14303                                                                  10987654321098765432109876543210
14304                                                                  xxxxxxxxxx0100101xxxx1xx0111001x
14305                                                                  sqxtn2.  */
14306                                                               return 171;
14307                                                             }
14308                                                         }
14309                                                       else
14310                                                         {
14311                                                           if (((word >> 30) & 0x1) == 0)
14312                                                             {
14313                                                               /* 33222222222211111111110000000000
14314                                                                  10987654321098765432109876543210
14315                                                                  xxxxxxxxxx0100101xxxx1xx0111010x
14316                                                                  uqxtn.  */
14317                                                               return 220;
14318                                                             }
14319                                                           else
14320                                                             {
14321                                                               /* 33222222222211111111110000000000
14322                                                                  10987654321098765432109876543210
14323                                                                  xxxxxxxxxx0100101xxxx1xx0111011x
14324                                                                  uqxtn2.  */
14325                                                               return 221;
14326                                                             }
14327                                                         }
14328                                                     }
14329                                                 }
14330                                               else
14331                                                 {
14332                                                   if (((word >> 29) & 0x1) == 0)
14333                                                     {
14334                                                       if (((word >> 30) & 0x1) == 0)
14335                                                         {
14336                                                           /* 33222222222211111111110000000000
14337                                                              10987654321098765432109876543210
14338                                                              xxxxxxxxxx010010xxxxx1xx0111100x
14339                                                              fmax.  */
14340                                                           return 830;
14341                                                         }
14342                                                       else
14343                                                         {
14344                                                           /* 33222222222211111111110000000000
14345                                                              10987654321098765432109876543210
14346                                                              xxxxxxxxxx010010xxxxx1xx0111101x
14347                                                              sqxtn.  */
14348                                                           return 480;
14349                                                         }
14350                                                     }
14351                                                   else
14352                                                     {
14353                                                       /* 33222222222211111111110000000000
14354                                                          10987654321098765432109876543210
14355                                                          xxxxxxxxxx010010xxxxx1xx011111xx
14356                                                          uqxtn.  */
14357                                                       return 509;
14358                                                     }
14359                                                 }
14360                                             }
14361                                           else
14362                                             {
14363                                               if (((word >> 16) & 0x1) == 0)
14364                                                 {
14365                                                   if (((word >> 19) & 0x1) == 0)
14366                                                     {
14367                                                       if (((word >> 20) & 0x1) == 0)
14368                                                         {
14369                                                           if (((word >> 28) & 0x1) == 0)
14370                                                             {
14371                                                               if (((word >> 29) & 0x1) == 0)
14372                                                                 {
14373                                                                   /* 33222222222211111111110000000000
14374                                                                      10987654321098765432109876543210
14375                                                                      xxxxxxxxxx0100110xx001xx011100xx
14376                                                                      fcmgt.  */
14377                                                                   return 188;
14378                                                                 }
14379                                                               else
14380                                                                 {
14381                                                                   /* 33222222222211111111110000000000
14382                                                                      10987654321098765432109876543210
14383                                                                      xxxxxxxxxx0100110xx001xx011101xx
14384                                                                      fcmge.  */
14385                                                                   return 239;
14386                                                                 }
14387                                                             }
14388                                                           else
14389                                                             {
14390                                                               if (((word >> 29) & 0x1) == 0)
14391                                                                 {
14392                                                                   /* 33222222222211111111110000000000
14393                                                                      10987654321098765432109876543210
14394                                                                      xxxxxxxxxx0100110xx001xx011110xx
14395                                                                      fcmgt.  */
14396                                                                   return 489;
14397                                                                 }
14398                                                               else
14399                                                                 {
14400                                                                   /* 33222222222211111111110000000000
14401                                                                      10987654321098765432109876543210
14402                                                                      xxxxxxxxxx0100110xx001xx011111xx
14403                                                                      fcmge.  */
14404                                                                   return 519;
14405                                                                 }
14406                                                             }
14407                                                         }
14408                                                       else
14409                                                         {
14410                                                           if (((word >> 23) & 0x1) == 0)
14411                                                             {
14412                                                               if (((word >> 28) & 0x1) == 0)
14413                                                                 {
14414                                                                   if (((word >> 29) & 0x1) == 0)
14415                                                                     {
14416                                                                       /* 33222222222211111111110000000000
14417                                                                          10987654321098765432109876543210
14418                                                                          xxxxxxxxxx0100110xx011x0011100xx
14419                                                                          fmaxnmv.  */
14420                                                                       return 35;
14421                                                                     }
14422                                                                   else
14423                                                                     {
14424                                                                       /* 33222222222211111111110000000000
14425                                                                          10987654321098765432109876543210
14426                                                                          xxxxxxxxxx0100110xx011x0011101xx
14427                                                                          fmaxnmv.  */
14428                                                                       return 34;
14429                                                                     }
14430                                                                 }
14431                                                               else
14432                                                                 {
14433                                                                   if (((word >> 29) & 0x1) == 0)
14434                                                                     {
14435                                                                       /* 33222222222211111111110000000000
14436                                                                          10987654321098765432109876543210
14437                                                                          xxxxxxxxxx0100110xx011x0011110xx
14438                                                                          fmaxnmp.  */
14439                                                                       return 533;
14440                                                                     }
14441                                                                   else
14442                                                                     {
14443                                                                       /* 33222222222211111111110000000000
14444                                                                          10987654321098765432109876543210
14445                                                                          xxxxxxxxxx0100110xx011x0011111xx
14446                                                                          fmaxnmp.  */
14447                                                                       return 532;
14448                                                                     }
14449                                                                 }
14450                                                             }
14451                                                           else
14452                                                             {
14453                                                               if (((word >> 28) & 0x1) == 0)
14454                                                                 {
14455                                                                   if (((word >> 29) & 0x1) == 0)
14456                                                                     {
14457                                                                       /* 33222222222211111111110000000000
14458                                                                          10987654321098765432109876543210
14459                                                                          xxxxxxxxxx0100110xx011x1011100xx
14460                                                                          fminnmv.  */
14461                                                                       return 39;
14462                                                                     }
14463                                                                   else
14464                                                                     {
14465                                                                       /* 33222222222211111111110000000000
14466                                                                          10987654321098765432109876543210
14467                                                                          xxxxxxxxxx0100110xx011x1011101xx
14468                                                                          fminnmv.  */
14469                                                                       return 38;
14470                                                                     }
14471                                                                 }
14472                                                               else
14473                                                                 {
14474                                                                   if (((word >> 29) & 0x1) == 0)
14475                                                                     {
14476                                                                       /* 33222222222211111111110000000000
14477                                                                          10987654321098765432109876543210
14478                                                                          xxxxxxxxxx0100110xx011x1011110xx
14479                                                                          fminnmp.  */
14480                                                                       return 539;
14481                                                                     }
14482                                                                   else
14483                                                                     {
14484                                                                       /* 33222222222211111111110000000000
14485                                                                          10987654321098765432109876543210
14486                                                                          xxxxxxxxxx0100110xx011x1011111xx
14487                                                                          fminnmp.  */
14488                                                                       return 538;
14489                                                                     }
14490                                                                 }
14491                                                             }
14492                                                         }
14493                                                     }
14494                                                   else
14495                                                     {
14496                                                       if (((word >> 28) & 0x1) == 0)
14497                                                         {
14498                                                           if (((word >> 29) & 0x1) == 0)
14499                                                             {
14500                                                               /* 33222222222211111111110000000000
14501                                                                  10987654321098765432109876543210
14502                                                                  xxxxxxxxxx0100110xx1x1xx011100xx
14503                                                                  fcmgt.  */
14504                                                               return 189;
14505                                                             }
14506                                                           else
14507                                                             {
14508                                                               /* 33222222222211111111110000000000
14509                                                                  10987654321098765432109876543210
14510                                                                  xxxxxxxxxx0100110xx1x1xx011101xx
14511                                                                  fcmge.  */
14512                                                               return 240;
14513                                                             }
14514                                                         }
14515                                                       else
14516                                                         {
14517                                                           if (((word >> 29) & 0x1) == 0)
14518                                                             {
14519                                                               /* 33222222222211111111110000000000
14520                                                                  10987654321098765432109876543210
14521                                                                  xxxxxxxxxx0100110xx1x1xx011110xx
14522                                                                  fcmgt.  */
14523                                                               return 490;
14524                                                             }
14525                                                           else
14526                                                             {
14527                                                               /* 33222222222211111111110000000000
14528                                                                  10987654321098765432109876543210
14529                                                                  xxxxxxxxxx0100110xx1x1xx011111xx
14530                                                                  fcmge.  */
14531                                                               return 520;
14532                                                             }
14533                                                         }
14534                                                     }
14535                                                 }
14536                                               else
14537                                                 {
14538                                                   if (((word >> 19) & 0x1) == 0)
14539                                                     {
14540                                                       if (((word >> 23) & 0x1) == 0)
14541                                                         {
14542                                                           if (((word >> 28) & 0x1) == 0)
14543                                                             {
14544                                                               if (((word >> 29) & 0x1) == 0)
14545                                                                 {
14546                                                                   /* 33222222222211111111110000000000
14547                                                                      10987654321098765432109876543210
14548                                                                      xxxxxxxxxx0100111xx0x1x0011100xx
14549                                                                      fcvtas.  */
14550                                                                   return 184;
14551                                                                 }
14552                                                               else
14553                                                                 {
14554                                                                   /* 33222222222211111111110000000000
14555                                                                      10987654321098765432109876543210
14556                                                                      xxxxxxxxxx0100111xx0x1x0011101xx
14557                                                                      fcvtau.  */
14558                                                                   return 232;
14559                                                                 }
14560                                                             }
14561                                                           else
14562                                                             {
14563                                                               if (((word >> 29) & 0x1) == 0)
14564                                                                 {
14565                                                                   /* 33222222222211111111110000000000
14566                                                                      10987654321098765432109876543210
14567                                                                      xxxxxxxxxx0100111xx0x1x0011110xx
14568                                                                      fcvtas.  */
14569                                                                   return 485;
14570                                                                 }
14571                                                               else
14572                                                                 {
14573                                                                   /* 33222222222211111111110000000000
14574                                                                      10987654321098765432109876543210
14575                                                                      xxxxxxxxxx0100111xx0x1x0011111xx
14576                                                                      fcvtau.  */
14577                                                                   return 515;
14578                                                                 }
14579                                                             }
14580                                                         }
14581                                                       else
14582                                                         {
14583                                                           if (((word >> 29) & 0x1) == 0)
14584                                                             {
14585                                                               /* 33222222222211111111110000000000
14586                                                                  10987654321098765432109876543210
14587                                                                  xxxxxxxxxx0100111xx0x1x10111x0xx
14588                                                                  urecpe.  */
14589                                                               return 204;
14590                                                             }
14591                                                           else
14592                                                             {
14593                                                               /* 33222222222211111111110000000000
14594                                                                  10987654321098765432109876543210
14595                                                                  xxxxxxxxxx0100111xx0x1x10111x1xx
14596                                                                  ursqrte.  */
14597                                                               return 251;
14598                                                             }
14599                                                         }
14600                                                     }
14601                                                   else
14602                                                     {
14603                                                       if (((word >> 28) & 0x1) == 0)
14604                                                         {
14605                                                           if (((word >> 29) & 0x1) == 0)
14606                                                             {
14607                                                               /* 33222222222211111111110000000000
14608                                                                  10987654321098765432109876543210
14609                                                                  xxxxxxxxxx0100111xx1x1xx011100xx
14610                                                                  fcvtas.  */
14611                                                               return 185;
14612                                                             }
14613                                                           else
14614                                                             {
14615                                                               /* 33222222222211111111110000000000
14616                                                                  10987654321098765432109876543210
14617                                                                  xxxxxxxxxx0100111xx1x1xx011101xx
14618                                                                  fcvtau.  */
14619                                                               return 233;
14620                                                             }
14621                                                         }
14622                                                       else
14623                                                         {
14624                                                           if (((word >> 29) & 0x1) == 0)
14625                                                             {
14626                                                               /* 33222222222211111111110000000000
14627                                                                  10987654321098765432109876543210
14628                                                                  xxxxxxxxxx0100111xx1x1xx011110xx
14629                                                                  fcvtas.  */
14630                                                               return 486;
14631                                                             }
14632                                                           else
14633                                                             {
14634                                                               /* 33222222222211111111110000000000
14635                                                                  10987654321098765432109876543210
14636                                                                  xxxxxxxxxx0100111xx1x1xx011111xx
14637                                                                  fcvtau.  */
14638                                                               return 516;
14639                                                             }
14640                                                         }
14641                                                     }
14642                                                 }
14643                                             }
14644                                         }
14645                                     }
14646                                   else
14647                                     {
14648                                       if (((word >> 14) & 0x1) == 0)
14649                                         {
14650                                           if (((word >> 15) & 0x1) == 0)
14651                                             {
14652                                               if (((word >> 28) & 0x1) == 0)
14653                                                 {
14654                                                   if (((word >> 16) & 0x1) == 0)
14655                                                     {
14656                                                       if (((word >> 29) & 0x1) == 0)
14657                                                         {
14658                                                           /* 33222222222211111111110000000000
14659                                                              10987654321098765432109876543210
14660                                                              xxxxxxxxxx0101000xxxx1xx011100xx
14661                                                              saddlp.  */
14662                                                           return 158;
14663                                                         }
14664                                                       else
14665                                                         {
14666                                                           /* 33222222222211111111110000000000
14667                                                              10987654321098765432109876543210
14668                                                              xxxxxxxxxx0101000xxxx1xx011101xx
14669                                                              uaddlp.  */
14670                                                           return 208;
14671                                                         }
14672                                                     }
14673                                                   else
14674                                                     {
14675                                                       if (((word >> 29) & 0x1) == 0)
14676                                                         {
14677                                                           if (((word >> 30) & 0x1) == 0)
14678                                                             {
14679                                                               /* 33222222222211111111110000000000
14680                                                                  10987654321098765432109876543210
14681                                                                  xxxxxxxxxx0101001xxxx1xx0111000x
14682                                                                  xtn.  */
14683                                                               return 168;
14684                                                             }
14685                                                           else
14686                                                             {
14687                                                               /* 33222222222211111111110000000000
14688                                                                  10987654321098765432109876543210
14689                                                                  xxxxxxxxxx0101001xxxx1xx0111001x
14690                                                                  xtn2.  */
14691                                                               return 169;
14692                                                             }
14693                                                         }
14694                                                       else
14695                                                         {
14696                                                           if (((word >> 30) & 0x1) == 0)
14697                                                             {
14698                                                               /* 33222222222211111111110000000000
14699                                                                  10987654321098765432109876543210
14700                                                                  xxxxxxxxxx0101001xxxx1xx0111010x
14701                                                                  sqxtun.  */
14702                                                               return 216;
14703                                                             }
14704                                                           else
14705                                                             {
14706                                                               /* 33222222222211111111110000000000
14707                                                                  10987654321098765432109876543210
14708                                                                  xxxxxxxxxx0101001xxxx1xx0111011x
14709                                                                  sqxtun2.  */
14710                                                               return 217;
14711                                                             }
14712                                                         }
14713                                                     }
14714                                                 }
14715                                               else
14716                                                 {
14717                                                   if (((word >> 29) & 0x1) == 0)
14718                                                     {
14719                                                       if (((word >> 30) & 0x1) == 0)
14720                                                         {
14721                                                           /* 33222222222211111111110000000000
14722                                                              10987654321098765432109876543210
14723                                                              xxxxxxxxxx010100xxxxx1xx0111100x
14724                                                              fadd.  */
14725                                                           return 826;
14726                                                         }
14727                                                       else
14728                                                         {
14729                                                           /* 33222222222211111111110000000000
14730                                                              10987654321098765432109876543210
14731                                                              xxxxxxxxxx010100xxxxx1xx0111101x
14732                                                              sha256su0.  */
14733                                                           return 671;
14734                                                         }
14735                                                     }
14736                                                   else
14737                                                     {
14738                                                       /* 33222222222211111111110000000000
14739                                                          10987654321098765432109876543210
14740                                                          xxxxxxxxxx010100xxxxx1xx011111xx
14741                                                          sqxtun.  */
14742                                                       return 508;
14743                                                     }
14744                                                 }
14745                                             }
14746                                           else
14747                                             {
14748                                               if (((word >> 16) & 0x1) == 0)
14749                                                 {
14750                                                   if (((word >> 20) & 0x1) == 0)
14751                                                     {
14752                                                       if (((word >> 28) & 0x1) == 0)
14753                                                         {
14754                                                           /* 33222222222211111111110000000000
14755                                                              10987654321098765432109876543210
14756                                                              xxxxxxxxxx0101010xxx01xx01110xxx
14757                                                              cmlt.  */
14758                                                           return 166;
14759                                                         }
14760                                                       else
14761                                                         {
14762                                                           /* 33222222222211111111110000000000
14763                                                              10987654321098765432109876543210
14764                                                              xxxxxxxxxx0101010xxx01xx01111xxx
14765                                                              cmlt.  */
14766                                                           return 478;
14767                                                         }
14768                                                     }
14769                                                   else
14770                                                     {
14771                                                       if (((word >> 29) & 0x1) == 0)
14772                                                         {
14773                                                           /* 33222222222211111111110000000000
14774                                                              10987654321098765432109876543210
14775                                                              xxxxxxxxxx0101010xxx11xx0111x0xx
14776                                                              smaxv.  */
14777                                                           return 28;
14778                                                         }
14779                                                       else
14780                                                         {
14781                                                           /* 33222222222211111111110000000000
14782                                                              10987654321098765432109876543210
14783                                                              xxxxxxxxxx0101010xxx11xx0111x1xx
14784                                                              umaxv.  */
14785                                                           return 32;
14786                                                         }
14787                                                     }
14788                                                 }
14789                                               else
14790                                                 {
14791                                                   if (((word >> 19) & 0x1) == 0)
14792                                                     {
14793                                                       if (((word >> 20) & 0x1) == 0)
14794                                                         {
14795                                                           if (((word >> 23) & 0x1) == 0)
14796                                                             {
14797                                                               if (((word >> 28) & 0x1) == 0)
14798                                                                 {
14799                                                                   if (((word >> 29) & 0x1) == 0)
14800                                                                     {
14801                                                                       /* 33222222222211111111110000000000
14802                                                                          10987654321098765432109876543210
14803                                                                          xxxxxxxxxx0101011xx001x0011100xx
14804                                                                          fcvtns.  */
14805                                                                       return 180;
14806                                                                     }
14807                                                                   else
14808                                                                     {
14809                                                                       /* 33222222222211111111110000000000
14810                                                                          10987654321098765432109876543210
14811                                                                          xxxxxxxxxx0101011xx001x0011101xx
14812                                                                          fcvtnu.  */
14813                                                                       return 228;
14814                                                                     }
14815                                                                 }
14816                                                               else
14817                                                                 {
14818                                                                   if (((word >> 29) & 0x1) == 0)
14819                                                                     {
14820                                                                       /* 33222222222211111111110000000000
14821                                                                          10987654321098765432109876543210
14822                                                                          xxxxxxxxxx0101011xx001x0011110xx
14823                                                                          fcvtns.  */
14824                                                                       return 481;
14825                                                                     }
14826                                                                   else
14827                                                                     {
14828                                                                       /* 33222222222211111111110000000000
14829                                                                          10987654321098765432109876543210
14830                                                                          xxxxxxxxxx0101011xx001x0011111xx
14831                                                                          fcvtnu.  */
14832                                                                       return 511;
14833                                                                     }
14834                                                                 }
14835                                                             }
14836                                                           else
14837                                                             {
14838                                                               if (((word >> 28) & 0x1) == 0)
14839                                                                 {
14840                                                                   if (((word >> 29) & 0x1) == 0)
14841                                                                     {
14842                                                                       /* 33222222222211111111110000000000
14843                                                                          10987654321098765432109876543210
14844                                                                          xxxxxxxxxx0101011xx001x1011100xx
14845                                                                          fcvtps.  */
14846                                                                       return 200;
14847                                                                     }
14848                                                                   else
14849                                                                     {
14850                                                                       /* 33222222222211111111110000000000
14851                                                                          10987654321098765432109876543210
14852                                                                          xxxxxxxxxx0101011xx001x1011101xx
14853                                                                          fcvtpu.  */
14854                                                                       return 247;
14855                                                                     }
14856                                                                 }
14857                                                               else
14858                                                                 {
14859                                                                   if (((word >> 29) & 0x1) == 0)
14860                                                                     {
14861                                                                       /* 33222222222211111111110000000000
14862                                                                          10987654321098765432109876543210
14863                                                                          xxxxxxxxxx0101011xx001x1011110xx
14864                                                                          fcvtps.  */
14865                                                                       return 495;
14866                                                                     }
14867                                                                   else
14868                                                                     {
14869                                                                       /* 33222222222211111111110000000000
14870                                                                          10987654321098765432109876543210
14871                                                                          xxxxxxxxxx0101011xx001x1011111xx
14872                                                                          fcvtpu.  */
14873                                                                       return 523;
14874                                                                     }
14875                                                                 }
14876                                                             }
14877                                                         }
14878                                                       else
14879                                                         {
14880                                                           if (((word >> 29) & 0x1) == 0)
14881                                                             {
14882                                                               /* 33222222222211111111110000000000
14883                                                                  10987654321098765432109876543210
14884                                                                  xxxxxxxxxx0101011xx011xx0111x0xx
14885                                                                  sminv.  */
14886                                                               return 29;
14887                                                             }
14888                                                           else
14889                                                             {
14890                                                               /* 33222222222211111111110000000000
14891                                                                  10987654321098765432109876543210
14892                                                                  xxxxxxxxxx0101011xx011xx0111x1xx
14893                                                                  uminv.  */
14894                                                               return 33;
14895                                                             }
14896                                                         }
14897                                                     }
14898                                                   else
14899                                                     {
14900                                                       if (((word >> 23) & 0x1) == 0)
14901                                                         {
14902                                                           if (((word >> 28) & 0x1) == 0)
14903                                                             {
14904                                                               if (((word >> 29) & 0x1) == 0)
14905                                                                 {
14906                                                                   /* 33222222222211111111110000000000
14907                                                                      10987654321098765432109876543210
14908                                                                      xxxxxxxxxx0101011xx1x1x0011100xx
14909                                                                      fcvtns.  */
14910                                                                   return 181;
14911                                                                 }
14912                                                               else
14913                                                                 {
14914                                                                   /* 33222222222211111111110000000000
14915                                                                      10987654321098765432109876543210
14916                                                                      xxxxxxxxxx0101011xx1x1x0011101xx
14917                                                                      fcvtnu.  */
14918                                                                   return 229;
14919                                                                 }
14920                                                             }
14921                                                           else
14922                                                             {
14923                                                               if (((word >> 29) & 0x1) == 0)
14924                                                                 {
14925                                                                   /* 33222222222211111111110000000000
14926                                                                      10987654321098765432109876543210
14927                                                                      xxxxxxxxxx0101011xx1x1x0011110xx
14928                                                                      fcvtns.  */
14929                                                                   return 482;
14930                                                                 }
14931                                                               else
14932                                                                 {
14933                                                                   /* 33222222222211111111110000000000
14934                                                                      10987654321098765432109876543210
14935                                                                      xxxxxxxxxx0101011xx1x1x0011111xx
14936                                                                      fcvtnu.  */
14937                                                                   return 512;
14938                                                                 }
14939                                                             }
14940                                                         }
14941                                                       else
14942                                                         {
14943                                                           if (((word >> 28) & 0x1) == 0)
14944                                                             {
14945                                                               if (((word >> 29) & 0x1) == 0)
14946                                                                 {
14947                                                                   /* 33222222222211111111110000000000
14948                                                                      10987654321098765432109876543210
14949                                                                      xxxxxxxxxx0101011xx1x1x1011100xx
14950                                                                      fcvtps.  */
14951                                                                   return 201;
14952                                                                 }
14953                                                               else
14954                                                                 {
14955                                                                   /* 33222222222211111111110000000000
14956                                                                      10987654321098765432109876543210
14957                                                                      xxxxxxxxxx0101011xx1x1x1011101xx
14958                                                                      fcvtpu.  */
14959                                                                   return 248;
14960                                                                 }
14961                                                             }
14962                                                           else
14963                                                             {
14964                                                               if (((word >> 29) & 0x1) == 0)
14965                                                                 {
14966                                                                   /* 33222222222211111111110000000000
14967                                                                      10987654321098765432109876543210
14968                                                                      xxxxxxxxxx0101011xx1x1x1011110xx
14969                                                                      fcvtps.  */
14970                                                                   return 496;
14971                                                                 }
14972                                                               else
14973                                                                 {
14974                                                                   /* 33222222222211111111110000000000
14975                                                                      10987654321098765432109876543210
14976                                                                      xxxxxxxxxx0101011xx1x1x1011111xx
14977                                                                      fcvtpu.  */
14978                                                                   return 524;
14979                                                                 }
14980                                                             }
14981                                                         }
14982                                                     }
14983                                                 }
14984                                             }
14985                                         }
14986                                       else
14987                                         {
14988                                           if (((word >> 15) & 0x1) == 0)
14989                                             {
14990                                               if (((word >> 28) & 0x1) == 0)
14991                                                 {
14992                                                   if (((word >> 16) & 0x1) == 0)
14993                                                     {
14994                                                       if (((word >> 19) & 0x1) == 0)
14995                                                         {
14996                                                           if (((word >> 29) & 0x1) == 0)
14997                                                             {
14998                                                               /* 33222222222211111111110000000000
14999                                                                  10987654321098765432109876543210
15000                                                                  xxxxxxxxxx0101100xx0x1xx011100xx
15001                                                                  sadalp.  */
15002                                                               return 162;
15003                                                             }
15004                                                           else
15005                                                             {
15006                                                               /* 33222222222211111111110000000000
15007                                                                  10987654321098765432109876543210
15008                                                                  xxxxxxxxxx0101100xx0x1xx011101xx
15009                                                                  uadalp.  */
15010                                                               return 211;
15011                                                             }
15012                                                         }
15013                                                       else
15014                                                         {
15015                                                           /* 33222222222211111111110000000000
15016                                                              10987654321098765432109876543210
15017                                                              xxxxxxxxxx0101100xx1x1xx01110xxx
15018                                                              aesmc.  */
15019                                                           return 667;
15020                                                         }
15021                                                     }
15022                                                   else
15023                                                     {
15024                                                       if (((word >> 29) & 0x1) == 0)
15025                                                         {
15026                                                           if (((word >> 30) & 0x1) == 0)
15027                                                             {
15028                                                               /* 33222222222211111111110000000000
15029                                                                  10987654321098765432109876543210
15030                                                                  xxxxxxxxxx0101101xxxx1xx0111000x
15031                                                                  fcvtn.  */
15032                                                               return 172;
15033                                                             }
15034                                                           else
15035                                                             {
15036                                                               /* 33222222222211111111110000000000
15037                                                                  10987654321098765432109876543210
15038                                                                  xxxxxxxxxx0101101xxxx1xx0111001x
15039                                                                  fcvtn2.  */
15040                                                               return 173;
15041                                                             }
15042                                                         }
15043                                                       else
15044                                                         {
15045                                                           if (((word >> 30) & 0x1) == 0)
15046                                                             {
15047                                                               /* 33222222222211111111110000000000
15048                                                                  10987654321098765432109876543210
15049                                                                  xxxxxxxxxx0101101xxxx1xx0111010x
15050                                                                  fcvtxn.  */
15051                                                               return 222;
15052                                                             }
15053                                                           else
15054                                                             {
15055                                                               /* 33222222222211111111110000000000
15056                                                                  10987654321098765432109876543210
15057                                                                  xxxxxxxxxx0101101xxxx1xx0111011x
15058                                                                  fcvtxn2.  */
15059                                                               return 223;
15060                                                             }
15061                                                         }
15062                                                     }
15063                                                 }
15064                                               else
15065                                                 {
15066                                                   if (((word >> 29) & 0x1) == 0)
15067                                                     {
15068                                                       /* 33222222222211111111110000000000
15069                                                          10987654321098765432109876543210
15070                                                          xxxxxxxxxx010110xxxxx1xx011110xx
15071                                                          fmaxnm.  */
15072                                                       return 834;
15073                                                     }
15074                                                   else
15075                                                     {
15076                                                       /* 33222222222211111111110000000000
15077                                                          10987654321098765432109876543210
15078                                                          xxxxxxxxxx010110xxxxx1xx011111xx
15079                                                          fcvtxn.  */
15080                                                       return 510;
15081                                                     }
15082                                                 }
15083                                             }
15084                                           else
15085                                             {
15086                                               if (((word >> 19) & 0x1) == 0)
15087                                                 {
15088                                                   if (((word >> 28) & 0x1) == 0)
15089                                                     {
15090                                                       /* 33222222222211111111110000000000
15091                                                          10987654321098765432109876543210
15092                                                          xxxxxxxxxx010111xxx0x1xx01110xxx
15093                                                          fcmlt.  */
15094                                                       return 192;
15095                                                     }
15096                                                   else
15097                                                     {
15098                                                       /* 33222222222211111111110000000000
15099                                                          10987654321098765432109876543210
15100                                                          xxxxxxxxxx010111xxx0x1xx01111xxx
15101                                                          fcmlt.  */
15102                                                       return 493;
15103                                                     }
15104                                                 }
15105                                               else
15106                                                 {
15107                                                   if (((word >> 28) & 0x1) == 0)
15108                                                     {
15109                                                       /* 33222222222211111111110000000000
15110                                                          10987654321098765432109876543210
15111                                                          xxxxxxxxxx010111xxx1x1xx01110xxx
15112                                                          fcmlt.  */
15113                                                       return 193;
15114                                                     }
15115                                                   else
15116                                                     {
15117                                                       /* 33222222222211111111110000000000
15118                                                          10987654321098765432109876543210
15119                                                          xxxxxxxxxx010111xxx1x1xx01111xxx
15120                                                          fcmlt.  */
15121                                                       return 494;
15122                                                     }
15123                                                 }
15124                                             }
15125                                         }
15126                                     }
15127                                 }
15128                               else
15129                                 {
15130                                   if (((word >> 13) & 0x1) == 0)
15131                                     {
15132                                       if (((word >> 14) & 0x1) == 0)
15133                                         {
15134                                           if (((word >> 15) & 0x1) == 0)
15135                                             {
15136                                               if (((word >> 28) & 0x1) == 0)
15137                                                 {
15138                                                   /* 33222222222211111111110000000000
15139                                                      10987654321098765432109876543210
15140                                                      xxxxxxxxxx011000xxxxx1xx01110xxx
15141                                                      rev16.  */
15142                                                   return 157;
15143                                                 }
15144                                               else
15145                                                 {
15146                                                   if (((word >> 30) & 0x1) == 0)
15147                                                     {
15148                                                       /* 33222222222211111111110000000000
15149                                                          10987654321098765432109876543210
15150                                                          xxxxxxxxxx011000xxxxx1xx01111x0x
15151                                                          fdiv.  */
15152                                                       return 824;
15153                                                     }
15154                                                   else
15155                                                     {
15156                                                       /* 33222222222211111111110000000000
15157                                                          10987654321098765432109876543210
15158                                                          xxxxxxxxxx011000xxxxx1xx01111x1x
15159                                                          sha1su1.  */
15160                                                       return 670;
15161                                                     }
15162                                                 }
15163                                             }
15164                                           else
15165                                             {
15166                                               if (((word >> 16) & 0x1) == 0)
15167                                                 {
15168                                                   if (((word >> 28) & 0x1) == 0)
15169                                                     {
15170                                                       if (((word >> 29) & 0x1) == 0)
15171                                                         {
15172                                                           /* 33222222222211111111110000000000
15173                                                              10987654321098765432109876543210
15174                                                              xxxxxxxxxx0110010xxxx1xx011100xx
15175                                                              cmeq.  */
15176                                                           return 165;
15177                                                         }
15178                                                       else
15179                                                         {
15180                                                           /* 33222222222211111111110000000000
15181                                                              10987654321098765432109876543210
15182                                                              xxxxxxxxxx0110010xxxx1xx011101xx
15183                                                              cmle.  */
15184                                                           return 214;
15185                                                         }
15186                                                     }
15187                                                   else
15188                                                     {
15189                                                       if (((word >> 29) & 0x1) == 0)
15190                                                         {
15191                                                           /* 33222222222211111111110000000000
15192                                                              10987654321098765432109876543210
15193                                                              xxxxxxxxxx0110010xxxx1xx011110xx
15194                                                              cmeq.  */
15195                                                           return 477;
15196                                                         }
15197                                                       else
15198                                                         {
15199                                                           /* 33222222222211111111110000000000
15200                                                              10987654321098765432109876543210
15201                                                              xxxxxxxxxx0110010xxxx1xx011111xx
15202                                                              cmle.  */
15203                                                           return 506;
15204                                                         }
15205                                                     }
15206                                                 }
15207                                               else
15208                                                 {
15209                                                   if (((word >> 19) & 0x1) == 0)
15210                                                     {
15211                                                       if (((word >> 23) & 0x1) == 0)
15212                                                         {
15213                                                           if (((word >> 29) & 0x1) == 0)
15214                                                             {
15215                                                               /* 33222222222211111111110000000000
15216                                                                  10987654321098765432109876543210
15217                                                                  xxxxxxxxxx0110011xx0x1x00111x0xx
15218                                                                  frintm.  */
15219                                                               return 178;
15220                                                             }
15221                                                           else
15222                                                             {
15223                                                               /* 33222222222211111111110000000000
15224                                                                  10987654321098765432109876543210
15225                                                                  xxxxxxxxxx0110011xx0x1x00111x1xx
15226                                                                  frintx.  */
15227                                                               return 226;
15228                                                             }
15229                                                         }
15230                                                       else
15231                                                         {
15232                                                           if (((word >> 29) & 0x1) == 0)
15233                                                             {
15234                                                               /* 33222222222211111111110000000000
15235                                                                  10987654321098765432109876543210
15236                                                                  xxxxxxxxxx0110011xx0x1x10111x0xx
15237                                                                  frintz.  */
15238                                                               return 198;
15239                                                             }
15240                                                           else
15241                                                             {
15242                                                               /* 33222222222211111111110000000000
15243                                                                  10987654321098765432109876543210
15244                                                                  xxxxxxxxxx0110011xx0x1x10111x1xx
15245                                                                  frinti.  */
15246                                                               return 245;
15247                                                             }
15248                                                         }
15249                                                     }
15250                                                   else
15251                                                     {
15252                                                       if (((word >> 23) & 0x1) == 0)
15253                                                         {
15254                                                           if (((word >> 29) & 0x1) == 0)
15255                                                             {
15256                                                               /* 33222222222211111111110000000000
15257                                                                  10987654321098765432109876543210
15258                                                                  xxxxxxxxxx0110011xx1x1x00111x0xx
15259                                                                  frintm.  */
15260                                                               return 179;
15261                                                             }
15262                                                           else
15263                                                             {
15264                                                               /* 33222222222211111111110000000000
15265                                                                  10987654321098765432109876543210
15266                                                                  xxxxxxxxxx0110011xx1x1x00111x1xx
15267                                                                  frintx.  */
15268                                                               return 227;
15269                                                             }
15270                                                         }
15271                                                       else
15272                                                         {
15273                                                           if (((word >> 29) & 0x1) == 0)
15274                                                             {
15275                                                               /* 33222222222211111111110000000000
15276                                                                  10987654321098765432109876543210
15277                                                                  xxxxxxxxxx0110011xx1x1x10111x0xx
15278                                                                  frintz.  */
15279                                                               return 199;
15280                                                             }
15281                                                           else
15282                                                             {
15283                                                               /* 33222222222211111111110000000000
15284                                                                  10987654321098765432109876543210
15285                                                                  xxxxxxxxxx0110011xx1x1x10111x1xx
15286                                                                  frinti.  */
15287                                                               return 246;
15288                                                             }
15289                                                         }
15290                                                     }
15291                                                 }
15292                                             }
15293                                         }
15294                                       else
15295                                         {
15296                                           if (((word >> 15) & 0x1) == 0)
15297                                             {
15298                                               if (((word >> 28) & 0x1) == 0)
15299                                                 {
15300                                                   if (((word >> 19) & 0x1) == 0)
15301                                                     {
15302                                                       if (((word >> 29) & 0x1) == 0)
15303                                                         {
15304                                                           /* 33222222222211111111110000000000
15305                                                              10987654321098765432109876543210
15306                                                              xxxxxxxxxx011010xxx0x1xx011100xx
15307                                                              cnt.  */
15308                                                           return 161;
15309                                                         }
15310                                                       else
15311                                                         {
15312                                                           if (((word >> 22) & 0x1) == 0)
15313                                                             {
15314                                                               /* 33222222222211111111110000000000
15315                                                                  10987654321098765432109876543210
15316                                                                  xxxxxxxxxx011010xxx0x10x011101xx
15317                                                                  not.  */
15318                                                               return 236;
15319                                                             }
15320                                                           else
15321                                                             {
15322                                                               /* 33222222222211111111110000000000
15323                                                                  10987654321098765432109876543210
15324                                                                  xxxxxxxxxx011010xxx0x11x011101xx
15325                                                                  rbit.  */
15326                                                               return 238;
15327                                                             }
15328                                                         }
15329                                                     }
15330                                                   else
15331                                                     {
15332                                                       /* 33222222222211111111110000000000
15333                                                          10987654321098765432109876543210
15334                                                          xxxxxxxxxx011010xxx1x1xx01110xxx
15335                                                          aesd.  */
15336                                                       return 666;
15337                                                     }
15338                                                 }
15339                                               else
15340                                                 {
15341                                                   /* 33222222222211111111110000000000
15342                                                      10987654321098765432109876543210
15343                                                      xxxxxxxxxx011010xxxxx1xx01111xxx
15344                                                      fmin.  */
15345                                                   return 832;
15346                                                 }
15347                                             }
15348                                           else
15349                                             {
15350                                               if (((word >> 16) & 0x1) == 0)
15351                                                 {
15352                                                   if (((word >> 19) & 0x1) == 0)
15353                                                     {
15354                                                       if (((word >> 20) & 0x1) == 0)
15355                                                         {
15356                                                           if (((word >> 28) & 0x1) == 0)
15357                                                             {
15358                                                               if (((word >> 29) & 0x1) == 0)
15359                                                                 {
15360                                                                   /* 33222222222211111111110000000000
15361                                                                      10987654321098765432109876543210
15362                                                                      xxxxxxxxxx0110110xx001xx011100xx
15363                                                                      fcmeq.  */
15364                                                                   return 190;
15365                                                                 }
15366                                                               else
15367                                                                 {
15368                                                                   /* 33222222222211111111110000000000
15369                                                                      10987654321098765432109876543210
15370                                                                      xxxxxxxxxx0110110xx001xx011101xx
15371                                                                      fcmle.  */
15372                                                                   return 241;
15373                                                                 }
15374                                                             }
15375                                                           else
15376                                                             {
15377                                                               if (((word >> 29) & 0x1) == 0)
15378                                                                 {
15379                                                                   /* 33222222222211111111110000000000
15380                                                                      10987654321098765432109876543210
15381                                                                      xxxxxxxxxx0110110xx001xx011110xx
15382                                                                      fcmeq.  */
15383                                                                   return 491;
15384                                                                 }
15385                                                               else
15386                                                                 {
15387                                                                   /* 33222222222211111111110000000000
15388                                                                      10987654321098765432109876543210
15389                                                                      xxxxxxxxxx0110110xx001xx011111xx
15390                                                                      fcmle.  */
15391                                                                   return 521;
15392                                                                 }
15393                                                             }
15394                                                         }
15395                                                       else
15396                                                         {
15397                                                           if (((word >> 29) & 0x1) == 0)
15398                                                             {
15399                                                               /* 33222222222211111111110000000000
15400                                                                  10987654321098765432109876543210
15401                                                                  xxxxxxxxxx0110110xx011xx0111x0xx
15402                                                                  faddp.  */
15403                                                               return 535;
15404                                                             }
15405                                                           else
15406                                                             {
15407                                                               /* 33222222222211111111110000000000
15408                                                                  10987654321098765432109876543210
15409                                                                  xxxxxxxxxx0110110xx011xx0111x1xx
15410                                                                  faddp.  */
15411                                                               return 534;
15412                                                             }
15413                                                         }
15414                                                     }
15415                                                   else
15416                                                     {
15417                                                       if (((word >> 28) & 0x1) == 0)
15418                                                         {
15419                                                           if (((word >> 29) & 0x1) == 0)
15420                                                             {
15421                                                               /* 33222222222211111111110000000000
15422                                                                  10987654321098765432109876543210
15423                                                                  xxxxxxxxxx0110110xx1x1xx011100xx
15424                                                                  fcmeq.  */
15425                                                               return 191;
15426                                                             }
15427                                                           else
15428                                                             {
15429                                                               /* 33222222222211111111110000000000
15430                                                                  10987654321098765432109876543210
15431                                                                  xxxxxxxxxx0110110xx1x1xx011101xx
15432                                                                  fcmle.  */
15433                                                               return 242;
15434                                                             }
15435                                                         }
15436                                                       else
15437                                                         {
15438                                                           if (((word >> 29) & 0x1) == 0)
15439                                                             {
15440                                                               /* 33222222222211111111110000000000
15441                                                                  10987654321098765432109876543210
15442                                                                  xxxxxxxxxx0110110xx1x1xx011110xx
15443                                                                  fcmeq.  */
15444                                                               return 492;
15445                                                             }
15446                                                           else
15447                                                             {
15448                                                               /* 33222222222211111111110000000000
15449                                                                  10987654321098765432109876543210
15450                                                                  xxxxxxxxxx0110110xx1x1xx011111xx
15451                                                                  fcmle.  */
15452                                                               return 522;
15453                                                             }
15454                                                         }
15455                                                     }
15456                                                 }
15457                                               else
15458                                                 {
15459                                                   if (((word >> 19) & 0x1) == 0)
15460                                                     {
15461                                                       if (((word >> 23) & 0x1) == 0)
15462                                                         {
15463                                                           if (((word >> 28) & 0x1) == 0)
15464                                                             {
15465                                                               if (((word >> 29) & 0x1) == 0)
15466                                                                 {
15467                                                                   /* 33222222222211111111110000000000
15468                                                                      10987654321098765432109876543210
15469                                                                      xxxxxxxxxx0110111xx0x1x0011100xx
15470                                                                      scvtf.  */
15471                                                                   return 186;
15472                                                                 }
15473                                                               else
15474                                                                 {
15475                                                                   /* 33222222222211111111110000000000
15476                                                                      10987654321098765432109876543210
15477                                                                      xxxxxxxxxx0110111xx0x1x0011101xx
15478                                                                      ucvtf.  */
15479                                                                   return 234;
15480                                                                 }
15481                                                             }
15482                                                           else
15483                                                             {
15484                                                               if (((word >> 29) & 0x1) == 0)
15485                                                                 {
15486                                                                   /* 33222222222211111111110000000000
15487                                                                      10987654321098765432109876543210
15488                                                                      xxxxxxxxxx0110111xx0x1x0011110xx
15489                                                                      scvtf.  */
15490                                                                   return 487;
15491                                                                 }
15492                                                               else
15493                                                                 {
15494                                                                   /* 33222222222211111111110000000000
15495                                                                      10987654321098765432109876543210
15496                                                                      xxxxxxxxxx0110111xx0x1x0011111xx
15497                                                                      ucvtf.  */
15498                                                                   return 517;
15499                                                                 }
15500                                                             }
15501                                                         }
15502                                                       else
15503                                                         {
15504                                                           if (((word >> 28) & 0x1) == 0)
15505                                                             {
15506                                                               if (((word >> 29) & 0x1) == 0)
15507                                                                 {
15508                                                                   /* 33222222222211111111110000000000
15509                                                                      10987654321098765432109876543210
15510                                                                      xxxxxxxxxx0110111xx0x1x1011100xx
15511                                                                      frecpe.  */
15512                                                                   return 205;
15513                                                                 }
15514                                                               else
15515                                                                 {
15516                                                                   /* 33222222222211111111110000000000
15517                                                                      10987654321098765432109876543210
15518                                                                      xxxxxxxxxx0110111xx0x1x1011101xx
15519                                                                      frsqrte.  */
15520                                                                   return 252;
15521                                                                 }
15522                                                             }
15523                                                           else
15524                                                             {
15525                                                               if (((word >> 29) & 0x1) == 0)
15526                                                                 {
15527                                                                   /* 33222222222211111111110000000000
15528                                                                      10987654321098765432109876543210
15529                                                                      xxxxxxxxxx0110111xx0x1x1011110xx
15530                                                                      frecpe.  */
15531                                                                   return 499;
15532                                                                 }
15533                                                               else
15534                                                                 {
15535                                                                   /* 33222222222211111111110000000000
15536                                                                      10987654321098765432109876543210
15537                                                                      xxxxxxxxxx0110111xx0x1x1011111xx
15538                                                                      frsqrte.  */
15539                                                                   return 527;
15540                                                                 }
15541                                                             }
15542                                                         }
15543                                                     }
15544                                                   else
15545                                                     {
15546                                                       if (((word >> 23) & 0x1) == 0)
15547                                                         {
15548                                                           if (((word >> 28) & 0x1) == 0)
15549                                                             {
15550                                                               if (((word >> 29) & 0x1) == 0)
15551                                                                 {
15552                                                                   /* 33222222222211111111110000000000
15553                                                                      10987654321098765432109876543210
15554                                                                      xxxxxxxxxx0110111xx1x1x0011100xx
15555                                                                      scvtf.  */
15556                                                                   return 187;
15557                                                                 }
15558                                                               else
15559                                                                 {
15560                                                                   /* 33222222222211111111110000000000
15561                                                                      10987654321098765432109876543210
15562                                                                      xxxxxxxxxx0110111xx1x1x0011101xx
15563                                                                      ucvtf.  */
15564                                                                   return 235;
15565                                                                 }
15566                                                             }
15567                                                           else
15568                                                             {
15569                                                               if (((word >> 29) & 0x1) == 0)
15570                                                                 {
15571                                                                   /* 33222222222211111111110000000000
15572                                                                      10987654321098765432109876543210
15573                                                                      xxxxxxxxxx0110111xx1x1x0011110xx
15574                                                                      scvtf.  */
15575                                                                   return 488;
15576                                                                 }
15577                                                               else
15578                                                                 {
15579                                                                   /* 33222222222211111111110000000000
15580                                                                      10987654321098765432109876543210
15581                                                                      xxxxxxxxxx0110111xx1x1x0011111xx
15582                                                                      ucvtf.  */
15583                                                                   return 518;
15584                                                                 }
15585                                                             }
15586                                                         }
15587                                                       else
15588                                                         {
15589                                                           if (((word >> 28) & 0x1) == 0)
15590                                                             {
15591                                                               if (((word >> 29) & 0x1) == 0)
15592                                                                 {
15593                                                                   /* 33222222222211111111110000000000
15594                                                                      10987654321098765432109876543210
15595                                                                      xxxxxxxxxx0110111xx1x1x1011100xx
15596                                                                      frecpe.  */
15597                                                                   return 206;
15598                                                                 }
15599                                                               else
15600                                                                 {
15601                                                                   /* 33222222222211111111110000000000
15602                                                                      10987654321098765432109876543210
15603                                                                      xxxxxxxxxx0110111xx1x1x1011101xx
15604                                                                      frsqrte.  */
15605                                                                   return 253;
15606                                                                 }
15607                                                             }
15608                                                           else
15609                                                             {
15610                                                               if (((word >> 29) & 0x1) == 0)
15611                                                                 {
15612                                                                   /* 33222222222211111111110000000000
15613                                                                      10987654321098765432109876543210
15614                                                                      xxxxxxxxxx0110111xx1x1x1011110xx
15615                                                                      frecpe.  */
15616                                                                   return 500;
15617                                                                 }
15618                                                               else
15619                                                                 {
15620                                                                   /* 33222222222211111111110000000000
15621                                                                      10987654321098765432109876543210
15622                                                                      xxxxxxxxxx0110111xx1x1x1011111xx
15623                                                                      frsqrte.  */
15624                                                                   return 528;
15625                                                                 }
15626                                                             }
15627                                                         }
15628                                                     }
15629                                                 }
15630                                             }
15631                                         }
15632                                     }
15633                                   else
15634                                     {
15635                                       if (((word >> 14) & 0x1) == 0)
15636                                         {
15637                                           if (((word >> 15) & 0x1) == 0)
15638                                             {
15639                                               if (((word >> 28) & 0x1) == 0)
15640                                                 {
15641                                                   if (((word >> 16) & 0x1) == 0)
15642                                                     {
15643                                                       if (((word >> 20) & 0x1) == 0)
15644                                                         {
15645                                                           if (((word >> 29) & 0x1) == 0)
15646                                                             {
15647                                                               /* 33222222222211111111110000000000
15648                                                                  10987654321098765432109876543210
15649                                                                  xxxxxxxxxx0111000xxx01xx011100xx
15650                                                                  suqadd.  */
15651                                                               return 159;
15652                                                             }
15653                                                           else
15654                                                             {
15655                                                               /* 33222222222211111111110000000000
15656                                                                  10987654321098765432109876543210
15657                                                                  xxxxxxxxxx0111000xxx01xx011101xx
15658                                                                  usqadd.  */
15659                                                               return 209;
15660                                                             }
15661                                                         }
15662                                                       else
15663                                                         {
15664                                                           if (((word >> 29) & 0x1) == 0)
15665                                                             {
15666                                                               /* 33222222222211111111110000000000
15667                                                                  10987654321098765432109876543210
15668                                                                  xxxxxxxxxx0111000xxx11xx011100xx
15669                                                                  saddlv.  */
15670                                                               return 27;
15671                                                             }
15672                                                           else
15673                                                             {
15674                                                               /* 33222222222211111111110000000000
15675                                                                  10987654321098765432109876543210
15676                                                                  xxxxxxxxxx0111000xxx11xx011101xx
15677                                                                  uaddlv.  */
15678                                                               return 31;
15679                                                             }
15680                                                         }
15681                                                     }
15682                                                   else
15683                                                     {
15684                                                       if (((word >> 30) & 0x1) == 0)
15685                                                         {
15686                                                           /* 33222222222211111111110000000000
15687                                                              10987654321098765432109876543210
15688                                                              xxxxxxxxxx0111001xxxx1xx01110x0x
15689                                                              shll.  */
15690                                                           return 218;
15691                                                         }
15692                                                       else
15693                                                         {
15694                                                           /* 33222222222211111111110000000000
15695                                                              10987654321098765432109876543210
15696                                                              xxxxxxxxxx0111001xxxx1xx01110x1x
15697                                                              shll2.  */
15698                                                           return 219;
15699                                                         }
15700                                                     }
15701                                                 }
15702                                               else
15703                                                 {
15704                                                   if (((word >> 29) & 0x1) == 0)
15705                                                     {
15706                                                       if (((word >> 30) & 0x1) == 0)
15707                                                         {
15708                                                           /* 33222222222211111111110000000000
15709                                                              10987654321098765432109876543210
15710                                                              xxxxxxxxxx011100xxxxx1xx0111100x
15711                                                              fsub.  */
15712                                                           return 828;
15713                                                         }
15714                                                       else
15715                                                         {
15716                                                           /* 33222222222211111111110000000000
15717                                                              10987654321098765432109876543210
15718                                                              xxxxxxxxxx011100xxxxx1xx0111101x
15719                                                              suqadd.  */
15720                                                           return 474;
15721                                                         }
15722                                                     }
15723                                                   else
15724                                                     {
15725                                                       /* 33222222222211111111110000000000
15726                                                          10987654321098765432109876543210
15727                                                          xxxxxxxxxx011100xxxxx1xx011111xx
15728                                                          usqadd.  */
15729                                                       return 503;
15730                                                     }
15731                                                 }
15732                                             }
15733                                           else
15734                                             {
15735                                               if (((word >> 16) & 0x1) == 0)
15736                                                 {
15737                                                   if (((word >> 28) & 0x1) == 0)
15738                                                     {
15739                                                       if (((word >> 29) & 0x1) == 0)
15740                                                         {
15741                                                           /* 33222222222211111111110000000000
15742                                                              10987654321098765432109876543210
15743                                                              xxxxxxxxxx0111010xxxx1xx011100xx
15744                                                              abs.  */
15745                                                           return 167;
15746                                                         }
15747                                                       else
15748                                                         {
15749                                                           /* 33222222222211111111110000000000
15750                                                              10987654321098765432109876543210
15751                                                              xxxxxxxxxx0111010xxxx1xx011101xx
15752                                                              neg.  */
15753                                                           return 215;
15754                                                         }
15755                                                     }
15756                                                   else
15757                                                     {
15758                                                       if (((word >> 29) & 0x1) == 0)
15759                                                         {
15760                                                           /* 33222222222211111111110000000000
15761                                                              10987654321098765432109876543210
15762                                                              xxxxxxxxxx0111010xxxx1xx011110xx
15763                                                              abs.  */
15764                                                           return 479;
15765                                                         }
15766                                                       else
15767                                                         {
15768                                                           /* 33222222222211111111110000000000
15769                                                              10987654321098765432109876543210
15770                                                              xxxxxxxxxx0111010xxxx1xx011111xx
15771                                                              neg.  */
15772                                                           return 507;
15773                                                         }
15774                                                     }
15775                                                 }
15776                                               else
15777                                                 {
15778                                                   if (((word >> 19) & 0x1) == 0)
15779                                                     {
15780                                                       if (((word >> 20) & 0x1) == 0)
15781                                                         {
15782                                                           if (((word >> 23) & 0x1) == 0)
15783                                                             {
15784                                                               if (((word >> 28) & 0x1) == 0)
15785                                                                 {
15786                                                                   if (((word >> 29) & 0x1) == 0)
15787                                                                     {
15788                                                                       /* 33222222222211111111110000000000
15789                                                                          10987654321098765432109876543210
15790                                                                          xxxxxxxxxx0111011xx001x0011100xx
15791                                                                          fcvtms.  */
15792                                                                       return 182;
15793                                                                     }
15794                                                                   else
15795                                                                     {
15796                                                                       /* 33222222222211111111110000000000
15797                                                                          10987654321098765432109876543210
15798                                                                          xxxxxxxxxx0111011xx001x0011101xx
15799                                                                          fcvtmu.  */
15800                                                                       return 230;
15801                                                                     }
15802                                                                 }
15803                                                               else
15804                                                                 {
15805                                                                   if (((word >> 29) & 0x1) == 0)
15806                                                                     {
15807                                                                       /* 33222222222211111111110000000000
15808                                                                          10987654321098765432109876543210
15809                                                                          xxxxxxxxxx0111011xx001x0011110xx
15810                                                                          fcvtms.  */
15811                                                                       return 483;
15812                                                                     }
15813                                                                   else
15814                                                                     {
15815                                                                       /* 33222222222211111111110000000000
15816                                                                          10987654321098765432109876543210
15817                                                                          xxxxxxxxxx0111011xx001x0011111xx
15818                                                                          fcvtmu.  */
15819                                                                       return 513;
15820                                                                     }
15821                                                                 }
15822                                                             }
15823                                                           else
15824                                                             {
15825                                                               if (((word >> 28) & 0x1) == 0)
15826                                                                 {
15827                                                                   if (((word >> 29) & 0x1) == 0)
15828                                                                     {
15829                                                                       /* 33222222222211111111110000000000
15830                                                                          10987654321098765432109876543210
15831                                                                          xxxxxxxxxx0111011xx001x1011100xx
15832                                                                          fcvtzs.  */
15833                                                                       return 202;
15834                                                                     }
15835                                                                   else
15836                                                                     {
15837                                                                       /* 33222222222211111111110000000000
15838                                                                          10987654321098765432109876543210
15839                                                                          xxxxxxxxxx0111011xx001x1011101xx
15840                                                                          fcvtzu.  */
15841                                                                       return 249;
15842                                                                     }
15843                                                                 }
15844                                                               else
15845                                                                 {
15846                                                                   if (((word >> 29) & 0x1) == 0)
15847                                                                     {
15848                                                                       /* 33222222222211111111110000000000
15849                                                                          10987654321098765432109876543210
15850                                                                          xxxxxxxxxx0111011xx001x1011110xx
15851                                                                          fcvtzs.  */
15852                                                                       return 497;
15853                                                                     }
15854                                                                   else
15855                                                                     {
15856                                                                       /* 33222222222211111111110000000000
15857                                                                          10987654321098765432109876543210
15858                                                                          xxxxxxxxxx0111011xx001x1011111xx
15859                                                                          fcvtzu.  */
15860                                                                       return 525;
15861                                                                     }
15862                                                                 }
15863                                                             }
15864                                                         }
15865                                                       else
15866                                                         {
15867                                                           if (((word >> 28) & 0x1) == 0)
15868                                                             {
15869                                                               /* 33222222222211111111110000000000
15870                                                                  10987654321098765432109876543210
15871                                                                  xxxxxxxxxx0111011xx011xx01110xxx
15872                                                                  addv.  */
15873                                                               return 30;
15874                                                             }
15875                                                           else
15876                                                             {
15877                                                               /* 33222222222211111111110000000000
15878                                                                  10987654321098765432109876543210
15879                                                                  xxxxxxxxxx0111011xx011xx01111xxx
15880                                                                  addp.  */
15881                                                               return 531;
15882                                                             }
15883                                                         }
15884                                                     }
15885                                                   else
15886                                                     {
15887                                                       if (((word >> 23) & 0x1) == 0)
15888                                                         {
15889                                                           if (((word >> 28) & 0x1) == 0)
15890                                                             {
15891                                                               if (((word >> 29) & 0x1) == 0)
15892                                                                 {
15893                                                                   /* 33222222222211111111110000000000
15894                                                                      10987654321098765432109876543210
15895                                                                      xxxxxxxxxx0111011xx1x1x0011100xx
15896                                                                      fcvtms.  */
15897                                                                   return 183;
15898                                                                 }
15899                                                               else
15900                                                                 {
15901                                                                   /* 33222222222211111111110000000000
15902                                                                      10987654321098765432109876543210
15903                                                                      xxxxxxxxxx0111011xx1x1x0011101xx
15904                                                                      fcvtmu.  */
15905                                                                   return 231;
15906                                                                 }
15907                                                             }
15908                                                           else
15909                                                             {
15910                                                               if (((word >> 29) & 0x1) == 0)
15911                                                                 {
15912                                                                   /* 33222222222211111111110000000000
15913                                                                      10987654321098765432109876543210
15914                                                                      xxxxxxxxxx0111011xx1x1x0011110xx
15915                                                                      fcvtms.  */
15916                                                                   return 484;
15917                                                                 }
15918                                                               else
15919                                                                 {
15920                                                                   /* 33222222222211111111110000000000
15921                                                                      10987654321098765432109876543210
15922                                                                      xxxxxxxxxx0111011xx1x1x0011111xx
15923                                                                      fcvtmu.  */
15924                                                                   return 514;
15925                                                                 }
15926                                                             }
15927                                                         }
15928                                                       else
15929                                                         {
15930                                                           if (((word >> 28) & 0x1) == 0)
15931                                                             {
15932                                                               if (((word >> 29) & 0x1) == 0)
15933                                                                 {
15934                                                                   /* 33222222222211111111110000000000
15935                                                                      10987654321098765432109876543210
15936                                                                      xxxxxxxxxx0111011xx1x1x1011100xx
15937                                                                      fcvtzs.  */
15938                                                                   return 203;
15939                                                                 }
15940                                                               else
15941                                                                 {
15942                                                                   /* 33222222222211111111110000000000
15943                                                                      10987654321098765432109876543210
15944                                                                      xxxxxxxxxx0111011xx1x1x1011101xx
15945                                                                      fcvtzu.  */
15946                                                                   return 250;
15947                                                                 }
15948                                                             }
15949                                                           else
15950                                                             {
15951                                                               if (((word >> 29) & 0x1) == 0)
15952                                                                 {
15953                                                                   /* 33222222222211111111110000000000
15954                                                                      10987654321098765432109876543210
15955                                                                      xxxxxxxxxx0111011xx1x1x1011110xx
15956                                                                      fcvtzs.  */
15957                                                                   return 498;
15958                                                                 }
15959                                                               else
15960                                                                 {
15961                                                                   /* 33222222222211111111110000000000
15962                                                                      10987654321098765432109876543210
15963                                                                      xxxxxxxxxx0111011xx1x1x1011111xx
15964                                                                      fcvtzu.  */
15965                                                                   return 526;
15966                                                                 }
15967                                                             }
15968                                                         }
15969                                                     }
15970                                                 }
15971                                             }
15972                                         }
15973                                       else
15974                                         {
15975                                           if (((word >> 15) & 0x1) == 0)
15976                                             {
15977                                               if (((word >> 28) & 0x1) == 0)
15978                                                 {
15979                                                   if (((word >> 16) & 0x1) == 0)
15980                                                     {
15981                                                       if (((word >> 19) & 0x1) == 0)
15982                                                         {
15983                                                           if (((word >> 29) & 0x1) == 0)
15984                                                             {
15985                                                               /* 33222222222211111111110000000000
15986                                                                  10987654321098765432109876543210
15987                                                                  xxxxxxxxxx0111100xx0x1xx011100xx
15988                                                                  sqabs.  */
15989                                                               return 163;
15990                                                             }
15991                                                           else
15992                                                             {
15993                                                               /* 33222222222211111111110000000000
15994                                                                  10987654321098765432109876543210
15995                                                                  xxxxxxxxxx0111100xx0x1xx011101xx
15996                                                                  sqneg.  */
15997                                                               return 212;
15998                                                             }
15999                                                         }
16000                                                       else
16001                                                         {
16002                                                           /* 33222222222211111111110000000000
16003                                                              10987654321098765432109876543210
16004                                                              xxxxxxxxxx0111100xx1x1xx01110xxx
16005                                                              aesimc.  */
16006                                                           return 668;
16007                                                         }
16008                                                     }
16009                                                   else
16010                                                     {
16011                                                       if (((word >> 30) & 0x1) == 0)
16012                                                         {
16013                                                           /* 33222222222211111111110000000000
16014                                                              10987654321098765432109876543210
16015                                                              xxxxxxxxxx0111101xxxx1xx01110x0x
16016                                                              fcvtl.  */
16017                                                           return 174;
16018                                                         }
16019                                                       else
16020                                                         {
16021                                                           /* 33222222222211111111110000000000
16022                                                              10987654321098765432109876543210
16023                                                              xxxxxxxxxx0111101xxxx1xx01110x1x
16024                                                              fcvtl2.  */
16025                                                           return 175;
16026                                                         }
16027                                                     }
16028                                                 }
16029                                               else
16030                                                 {
16031                                                   if (((word >> 29) & 0x1) == 0)
16032                                                     {
16033                                                       if (((word >> 30) & 0x1) == 0)
16034                                                         {
16035                                                           /* 33222222222211111111110000000000
16036                                                              10987654321098765432109876543210
16037                                                              xxxxxxxxxx011110xxxxx1xx0111100x
16038                                                              fminnm.  */
16039                                                           return 836;
16040                                                         }
16041                                                       else
16042                                                         {
16043                                                           /* 33222222222211111111110000000000
16044                                                              10987654321098765432109876543210
16045                                                              xxxxxxxxxx011110xxxxx1xx0111101x
16046                                                              sqabs.  */
16047                                                           return 475;
16048                                                         }
16049                                                     }
16050                                                   else
16051                                                     {
16052                                                       /* 33222222222211111111110000000000
16053                                                          10987654321098765432109876543210
16054                                                          xxxxxxxxxx011110xxxxx1xx011111xx
16055                                                          sqneg.  */
16056                                                       return 504;
16057                                                     }
16058                                                 }
16059                                             }
16060                                           else
16061                                             {
16062                                               if (((word >> 16) & 0x1) == 0)
16063                                                 {
16064                                                   if (((word >> 19) & 0x1) == 0)
16065                                                     {
16066                                                       if (((word >> 20) & 0x1) == 0)
16067                                                         {
16068                                                           if (((word >> 29) & 0x1) == 0)
16069                                                             {
16070                                                               /* 33222222222211111111110000000000
16071                                                                  10987654321098765432109876543210
16072                                                                  xxxxxxxxxx0111110xx001xx0111x0xx
16073                                                                  fabs.  */
16074                                                               return 194;
16075                                                             }
16076                                                           else
16077                                                             {
16078                                                               /* 33222222222211111111110000000000
16079                                                                  10987654321098765432109876543210
16080                                                                  xxxxxxxxxx0111110xx001xx0111x1xx
16081                                                                  fneg.  */
16082                                                               return 243;
16083                                                             }
16084                                                         }
16085                                                       else
16086                                                         {
16087                                                           if (((word >> 23) & 0x1) == 0)
16088                                                             {
16089                                                               if (((word >> 28) & 0x1) == 0)
16090                                                                 {
16091                                                                   if (((word >> 29) & 0x1) == 0)
16092                                                                     {
16093                                                                       /* 33222222222211111111110000000000
16094                                                                          10987654321098765432109876543210
16095                                                                          xxxxxxxxxx0111110xx011x0011100xx
16096                                                                          fmaxv.  */
16097                                                                       return 37;
16098                                                                     }
16099                                                                   else
16100                                                                     {
16101                                                                       /* 33222222222211111111110000000000
16102                                                                          10987654321098765432109876543210
16103                                                                          xxxxxxxxxx0111110xx011x0011101xx
16104                                                                          fmaxv.  */
16105                                                                       return 36;
16106                                                                     }
16107                                                                 }
16108                                                               else
16109                                                                 {
16110                                                                   if (((word >> 29) & 0x1) == 0)
16111                                                                     {
16112                                                                       /* 33222222222211111111110000000000
16113                                                                          10987654321098765432109876543210
16114                                                                          xxxxxxxxxx0111110xx011x0011110xx
16115                                                                          fmaxp.  */
16116                                                                       return 537;
16117                                                                     }
16118                                                                   else
16119                                                                     {
16120                                                                       /* 33222222222211111111110000000000
16121                                                                          10987654321098765432109876543210
16122                                                                          xxxxxxxxxx0111110xx011x0011111xx
16123                                                                          fmaxp.  */
16124                                                                       return 536;
16125                                                                     }
16126                                                                 }
16127                                                             }
16128                                                           else
16129                                                             {
16130                                                               if (((word >> 28) & 0x1) == 0)
16131                                                                 {
16132                                                                   if (((word >> 29) & 0x1) == 0)
16133                                                                     {
16134                                                                       /* 33222222222211111111110000000000
16135                                                                          10987654321098765432109876543210
16136                                                                          xxxxxxxxxx0111110xx011x1011100xx
16137                                                                          fminv.  */
16138                                                                       return 41;
16139                                                                     }
16140                                                                   else
16141                                                                     {
16142                                                                       /* 33222222222211111111110000000000
16143                                                                          10987654321098765432109876543210
16144                                                                          xxxxxxxxxx0111110xx011x1011101xx
16145                                                                          fminv.  */
16146                                                                       return 40;
16147                                                                     }
16148                                                                 }
16149                                                               else
16150                                                                 {
16151                                                                   if (((word >> 29) & 0x1) == 0)
16152                                                                     {
16153                                                                       /* 33222222222211111111110000000000
16154                                                                          10987654321098765432109876543210
16155                                                                          xxxxxxxxxx0111110xx011x1011110xx
16156                                                                          fminp.  */
16157                                                                       return 541;
16158                                                                     }
16159                                                                   else
16160                                                                     {
16161                                                                       /* 33222222222211111111110000000000
16162                                                                          10987654321098765432109876543210
16163                                                                          xxxxxxxxxx0111110xx011x1011111xx
16164                                                                          fminp.  */
16165                                                                       return 540;
16166                                                                     }
16167                                                                 }
16168                                                             }
16169                                                         }
16170                                                     }
16171                                                   else
16172                                                     {
16173                                                       if (((word >> 29) & 0x1) == 0)
16174                                                         {
16175                                                           /* 33222222222211111111110000000000
16176                                                              10987654321098765432109876543210
16177                                                              xxxxxxxxxx0111110xx1x1xx0111x0xx
16178                                                              fabs.  */
16179                                                           return 195;
16180                                                         }
16181                                                       else
16182                                                         {
16183                                                           /* 33222222222211111111110000000000
16184                                                              10987654321098765432109876543210
16185                                                              xxxxxxxxxx0111110xx1x1xx0111x1xx
16186                                                              fneg.  */
16187                                                           return 244;
16188                                                         }
16189                                                     }
16190                                                 }
16191                                               else
16192                                                 {
16193                                                   if (((word >> 19) & 0x1) == 0)
16194                                                     {
16195                                                       if (((word >> 28) & 0x1) == 0)
16196                                                         {
16197                                                           /* 33222222222211111111110000000000
16198                                                              10987654321098765432109876543210
16199                                                              xxxxxxxxxx0111111xx0x1xx01110xxx
16200                                                              fsqrt.  */
16201                                                           return 254;
16202                                                         }
16203                                                       else
16204                                                         {
16205                                                           /* 33222222222211111111110000000000
16206                                                              10987654321098765432109876543210
16207                                                              xxxxxxxxxx0111111xx0x1xx01111xxx
16208                                                              frecpx.  */
16209                                                           return 501;
16210                                                         }
16211                                                     }
16212                                                   else
16213                                                     {
16214                                                       if (((word >> 28) & 0x1) == 0)
16215                                                         {
16216                                                           /* 33222222222211111111110000000000
16217                                                              10987654321098765432109876543210
16218                                                              xxxxxxxxxx0111111xx1x1xx01110xxx
16219                                                              fsqrt.  */
16220                                                           return 255;
16221                                                         }
16222                                                       else
16223                                                         {
16224                                                           /* 33222222222211111111110000000000
16225                                                              10987654321098765432109876543210
16226                                                              xxxxxxxxxx0111111xx1x1xx01111xxx
16227                                                              frecpx.  */
16228                                                           return 502;
16229                                                         }
16230                                                     }
16231                                                 }
16232                                             }
16233                                         }
16234                                     }
16235                                 }
16236                             }
16237                         }
16238                       else
16239                         {
16240                           if (((word >> 11) & 0x1) == 0)
16241                             {
16242                               if (((word >> 28) & 0x1) == 0)
16243                                 {
16244                                   if (((word >> 12) & 0x1) == 0)
16245                                     {
16246                                       if (((word >> 13) & 0x1) == 0)
16247                                         {
16248                                           if (((word >> 14) & 0x1) == 0)
16249                                             {
16250                                               if (((word >> 15) & 0x1) == 0)
16251                                                 {
16252                                                   if (((word >> 29) & 0x1) == 0)
16253                                                     {
16254                                                       /* 33222222222211111111110000000000
16255                                                          10987654321098765432109876543210
16256                                                          xxxxxxxxxx100000xxxxx1xx011100xx
16257                                                          shadd.  */
16258                                                       return 262;
16259                                                     }
16260                                                   else
16261                                                     {
16262                                                       /* 33222222222211111111110000000000
16263                                                          10987654321098765432109876543210
16264                                                          xxxxxxxxxx100000xxxxx1xx011101xx
16265                                                          uhadd.  */
16266                                                       return 314;
16267                                                     }
16268                                                 }
16269                                               else
16270                                                 {
16271                                                   if (((word >> 29) & 0x1) == 0)
16272                                                     {
16273                                                       /* 33222222222211111111110000000000
16274                                                          10987654321098765432109876543210
16275                                                          xxxxxxxxxx100001xxxxx1xx011100xx
16276                                                          add.  */
16277                                                       return 277;
16278                                                     }
16279                                                   else
16280                                                     {
16281                                                       /* 33222222222211111111110000000000
16282                                                          10987654321098765432109876543210
16283                                                          xxxxxxxxxx100001xxxxx1xx011101xx
16284                                                          sub.  */
16285                                                       return 329;
16286                                                     }
16287                                                 }
16288                                             }
16289                                           else
16290                                             {
16291                                               if (((word >> 15) & 0x1) == 0)
16292                                                 {
16293                                                   if (((word >> 29) & 0x1) == 0)
16294                                                     {
16295                                                       /* 33222222222211111111110000000000
16296                                                          10987654321098765432109876543210
16297                                                          xxxxxxxxxx100010xxxxx1xx011100xx
16298                                                          sshl.  */
16299                                                       return 269;
16300                                                     }
16301                                                   else
16302                                                     {
16303                                                       /* 33222222222211111111110000000000
16304                                                          10987654321098765432109876543210
16305                                                          xxxxxxxxxx100010xxxxx1xx011101xx
16306                                                          ushl.  */
16307                                                       return 321;
16308                                                     }
16309                                                 }
16310                                               else
16311                                                 {
16312                                                   if (((word >> 23) & 0x1) == 0)
16313                                                     {
16314                                                       if (((word >> 29) & 0x1) == 0)
16315                                                         {
16316                                                           /* 33222222222211111111110000000000
16317                                                              10987654321098765432109876543210
16318                                                              xxxxxxxxxx100011xxxxx1x0011100xx
16319                                                              fmaxnm.  */
16320                                                           return 285;
16321                                                         }
16322                                                       else
16323                                                         {
16324                                                           /* 33222222222211111111110000000000
16325                                                              10987654321098765432109876543210
16326                                                              xxxxxxxxxx100011xxxxx1x0011101xx
16327                                                              fmaxnmp.  */
16328                                                           return 336;
16329                                                         }
16330                                                     }
16331                                                   else
16332                                                     {
16333                                                       if (((word >> 29) & 0x1) == 0)
16334                                                         {
16335                                                           /* 33222222222211111111110000000000
16336                                                              10987654321098765432109876543210
16337                                                              xxxxxxxxxx100011xxxxx1x1011100xx
16338                                                              fminnm.  */
16339                                                           return 301;
16340                                                         }
16341                                                       else
16342                                                         {
16343                                                           /* 33222222222211111111110000000000
16344                                                              10987654321098765432109876543210
16345                                                              xxxxxxxxxx100011xxxxx1x1011101xx
16346                                                              fminnmp.  */
16347                                                           return 352;
16348                                                         }
16349                                                     }
16350                                                 }
16351                                             }
16352                                         }
16353                                       else
16354                                         {
16355                                           if (((word >> 14) & 0x1) == 0)
16356                                             {
16357                                               if (((word >> 15) & 0x1) == 0)
16358                                                 {
16359                                                   if (((word >> 29) & 0x1) == 0)
16360                                                     {
16361                                                       /* 33222222222211111111110000000000
16362                                                          10987654321098765432109876543210
16363                                                          xxxxxxxxxx100100xxxxx1xx011100xx
16364                                                          shsub.  */
16365                                                       return 265;
16366                                                     }
16367                                                   else
16368                                                     {
16369                                                       /* 33222222222211111111110000000000
16370                                                          10987654321098765432109876543210
16371                                                          xxxxxxxxxx100100xxxxx1xx011101xx
16372                                                          uhsub.  */
16373                                                       return 317;
16374                                                     }
16375                                                 }
16376                                               else
16377                                                 {
16378                                                   if (((word >> 29) & 0x1) == 0)
16379                                                     {
16380                                                       /* 33222222222211111111110000000000
16381                                                          10987654321098765432109876543210
16382                                                          xxxxxxxxxx100101xxxxx1xx011100xx
16383                                                          smaxp.  */
16384                                                       return 281;
16385                                                     }
16386                                                   else
16387                                                     {
16388                                                       /* 33222222222211111111110000000000
16389                                                          10987654321098765432109876543210
16390                                                          xxxxxxxxxx100101xxxxx1xx011101xx
16391                                                          umaxp.  */
16392                                                       return 333;
16393                                                     }
16394                                                 }
16395                                             }
16396                                           else
16397                                             {
16398                                               if (((word >> 15) & 0x1) == 0)
16399                                                 {
16400                                                   if (((word >> 29) & 0x1) == 0)
16401                                                     {
16402                                                       /* 33222222222211111111110000000000
16403                                                          10987654321098765432109876543210
16404                                                          xxxxxxxxxx100110xxxxx1xx011100xx
16405                                                          smax.  */
16406                                                       return 273;
16407                                                     }
16408                                                   else
16409                                                     {
16410                                                       /* 33222222222211111111110000000000
16411                                                          10987654321098765432109876543210
16412                                                          xxxxxxxxxx100110xxxxx1xx011101xx
16413                                                          umax.  */
16414                                                       return 325;
16415                                                     }
16416                                                 }
16417                                               else
16418                                                 {
16419                                                   if (((word >> 23) & 0x1) == 0)
16420                                                     {
16421                                                       if (((word >> 29) & 0x1) == 0)
16422                                                         {
16423                                                           /* 33222222222211111111110000000000
16424                                                              10987654321098765432109876543210
16425                                                              xxxxxxxxxx100111xxxxx1x0011100xx
16426                                                              fcmeq.  */
16427                                                           return 293;
16428                                                         }
16429                                                       else
16430                                                         {
16431                                                           /* 33222222222211111111110000000000
16432                                                              10987654321098765432109876543210
16433                                                              xxxxxxxxxx100111xxxxx1x0011101xx
16434                                                              fcmge.  */
16435                                                           return 342;
16436                                                         }
16437                                                     }
16438                                                   else
16439                                                     {
16440                                                       /* 33222222222211111111110000000000
16441                                                          10987654321098765432109876543210
16442                                                          xxxxxxxxxx100111xxxxx1x101110xxx
16443                                                          fcmgt.  */
16444                                                       return 356;
16445                                                     }
16446                                                 }
16447                                             }
16448                                         }
16449                                     }
16450                                   else
16451                                     {
16452                                       if (((word >> 13) & 0x1) == 0)
16453                                         {
16454                                           if (((word >> 14) & 0x1) == 0)
16455                                             {
16456                                               if (((word >> 15) & 0x1) == 0)
16457                                                 {
16458                                                   if (((word >> 29) & 0x1) == 0)
16459                                                     {
16460                                                       /* 33222222222211111111110000000000
16461                                                          10987654321098765432109876543210
16462                                                          xxxxxxxxxx101000xxxxx1xx011100xx
16463                                                          srhadd.  */
16464                                                       return 264;
16465                                                     }
16466                                                   else
16467                                                     {
16468                                                       /* 33222222222211111111110000000000
16469                                                          10987654321098765432109876543210
16470                                                          xxxxxxxxxx101000xxxxx1xx011101xx
16471                                                          urhadd.  */
16472                                                       return 316;
16473                                                     }
16474                                                 }
16475                                               else
16476                                                 {
16477                                                   if (((word >> 29) & 0x1) == 0)
16478                                                     {
16479                                                       /* 33222222222211111111110000000000
16480                                                          10987654321098765432109876543210
16481                                                          xxxxxxxxxx101001xxxxx1xx011100xx
16482                                                          mla.  */
16483                                                       return 279;
16484                                                     }
16485                                                   else
16486                                                     {
16487                                                       /* 33222222222211111111110000000000
16488                                                          10987654321098765432109876543210
16489                                                          xxxxxxxxxx101001xxxxx1xx011101xx
16490                                                          mls.  */
16491                                                       return 331;
16492                                                     }
16493                                                 }
16494                                             }
16495                                           else
16496                                             {
16497                                               if (((word >> 15) & 0x1) == 0)
16498                                                 {
16499                                                   if (((word >> 29) & 0x1) == 0)
16500                                                     {
16501                                                       /* 33222222222211111111110000000000
16502                                                          10987654321098765432109876543210
16503                                                          xxxxxxxxxx101010xxxxx1xx011100xx
16504                                                          srshl.  */
16505                                                       return 271;
16506                                                     }
16507                                                   else
16508                                                     {
16509                                                       /* 33222222222211111111110000000000
16510                                                          10987654321098765432109876543210
16511                                                          xxxxxxxxxx101010xxxxx1xx011101xx
16512                                                          urshl.  */
16513                                                       return 323;
16514                                                     }
16515                                                 }
16516                                               else
16517                                                 {
16518                                                   if (((word >> 23) & 0x1) == 0)
16519                                                     {
16520                                                       if (((word >> 29) & 0x1) == 0)
16521                                                         {
16522                                                           /* 33222222222211111111110000000000
16523                                                              10987654321098765432109876543210
16524                                                              xxxxxxxxxx101011xxxxx1x0011100xx
16525                                                              fadd.  */
16526                                                           return 289;
16527                                                         }
16528                                                       else
16529                                                         {
16530                                                           /* 33222222222211111111110000000000
16531                                                              10987654321098765432109876543210
16532                                                              xxxxxxxxxx101011xxxxx1x0011101xx
16533                                                              faddp.  */
16534                                                           return 338;
16535                                                         }
16536                                                     }
16537                                                   else
16538                                                     {
16539                                                       if (((word >> 29) & 0x1) == 0)
16540                                                         {
16541                                                           /* 33222222222211111111110000000000
16542                                                              10987654321098765432109876543210
16543                                                              xxxxxxxxxx101011xxxxx1x1011100xx
16544                                                              fsub.  */
16545                                                           return 305;
16546                                                         }
16547                                                       else
16548                                                         {
16549                                                           /* 33222222222211111111110000000000
16550                                                              10987654321098765432109876543210
16551                                                              xxxxxxxxxx101011xxxxx1x1011101xx
16552                                                              fabd.  */
16553                                                           return 354;
16554                                                         }
16555                                                     }
16556                                                 }
16557                                             }
16558                                         }
16559                                       else
16560                                         {
16561                                           if (((word >> 14) & 0x1) == 0)
16562                                             {
16563                                               if (((word >> 15) & 0x1) == 0)
16564                                                 {
16565                                                   if (((word >> 29) & 0x1) == 0)
16566                                                     {
16567                                                       /* 33222222222211111111110000000000
16568                                                          10987654321098765432109876543210
16569                                                          xxxxxxxxxx101100xxxxx1xx011100xx
16570                                                          cmgt.  */
16571                                                       return 267;
16572                                                     }
16573                                                   else
16574                                                     {
16575                                                       /* 33222222222211111111110000000000
16576                                                          10987654321098765432109876543210
16577                                                          xxxxxxxxxx101100xxxxx1xx011101xx
16578                                                          cmhi.  */
16579                                                       return 319;
16580                                                     }
16581                                                 }
16582                                               else
16583                                                 {
16584                                                   if (((word >> 29) & 0x1) == 0)
16585                                                     {
16586                                                       /* 33222222222211111111110000000000
16587                                                          10987654321098765432109876543210
16588                                                          xxxxxxxxxx101101xxxxx1xx011100xx
16589                                                          sqdmulh.  */
16590                                                       return 283;
16591                                                     }
16592                                                   else
16593                                                     {
16594                                                       /* 33222222222211111111110000000000
16595                                                          10987654321098765432109876543210
16596                                                          xxxxxxxxxx101101xxxxx1xx011101xx
16597                                                          sqrdmulh.  */
16598                                                       return 335;
16599                                                     }
16600                                                 }
16601                                             }
16602                                           else
16603                                             {
16604                                               if (((word >> 15) & 0x1) == 0)
16605                                                 {
16606                                                   if (((word >> 29) & 0x1) == 0)
16607                                                     {
16608                                                       /* 33222222222211111111110000000000
16609                                                          10987654321098765432109876543210
16610                                                          xxxxxxxxxx101110xxxxx1xx011100xx
16611                                                          sabd.  */
16612                                                       return 275;
16613                                                     }
16614                                                   else
16615                                                     {
16616                                                       /* 33222222222211111111110000000000
16617                                                          10987654321098765432109876543210
16618                                                          xxxxxxxxxx101110xxxxx1xx011101xx
16619                                                          uabd.  */
16620                                                       return 327;
16621                                                     }
16622                                                 }
16623                                               else
16624                                                 {
16625                                                   if (((word >> 23) & 0x1) == 0)
16626                                                     {
16627                                                       if (((word >> 29) & 0x1) == 0)
16628                                                         {
16629                                                           /* 33222222222211111111110000000000
16630                                                              10987654321098765432109876543210
16631                                                              xxxxxxxxxx101111xxxxx1x0011100xx
16632                                                              fmax.  */
16633                                                           return 295;
16634                                                         }
16635                                                       else
16636                                                         {
16637                                                           /* 33222222222211111111110000000000
16638                                                              10987654321098765432109876543210
16639                                                              xxxxxxxxxx101111xxxxx1x0011101xx
16640                                                              fmaxp.  */
16641                                                           return 346;
16642                                                         }
16643                                                     }
16644                                                   else
16645                                                     {
16646                                                       if (((word >> 29) & 0x1) == 0)
16647                                                         {
16648                                                           /* 33222222222211111111110000000000
16649                                                              10987654321098765432109876543210
16650                                                              xxxxxxxxxx101111xxxxx1x1011100xx
16651                                                              fmin.  */
16652                                                           return 307;
16653                                                         }
16654                                                       else
16655                                                         {
16656                                                           /* 33222222222211111111110000000000
16657                                                              10987654321098765432109876543210
16658                                                              xxxxxxxxxx101111xxxxx1x1011101xx
16659                                                              fminp.  */
16660                                                           return 360;
16661                                                         }
16662                                                     }
16663                                                 }
16664                                             }
16665                                         }
16666                                     }
16667                                 }
16668                               else
16669                                 {
16670                                   if (((word >> 29) & 0x1) == 0)
16671                                     {
16672                                       if (((word >> 30) & 0x1) == 0)
16673                                         {
16674                                           if (((word >> 4) & 0x1) == 0)
16675                                             {
16676                                               /* 33222222222211111111110000000000
16677                                                  10987654321098765432109876543210
16678                                                  xxxx0xxxxx10xxxxxxxxx1xx0111100x
16679                                                  fccmp.  */
16680                                               return 787;
16681                                             }
16682                                           else
16683                                             {
16684                                               /* 33222222222211111111110000000000
16685                                                  10987654321098765432109876543210
16686                                                  xxxx1xxxxx10xxxxxxxxx1xx0111100x
16687                                                  fccmpe.  */
16688                                               return 789;
16689                                             }
16690                                         }
16691                                       else
16692                                         {
16693                                           if (((word >> 12) & 0x1) == 0)
16694                                             {
16695                                               if (((word >> 13) & 0x1) == 0)
16696                                                 {
16697                                                   if (((word >> 14) & 0x1) == 0)
16698                                                     {
16699                                                       /* 33222222222211111111110000000000
16700                                                          10987654321098765432109876543210
16701                                                          xxxxxxxxxx10000xxxxxx1xx0111101x
16702                                                          add.  */
16703                                                       return 559;
16704                                                     }
16705                                                   else
16706                                                     {
16707                                                       /* 33222222222211111111110000000000
16708                                                          10987654321098765432109876543210
16709                                                          xxxxxxxxxx10001xxxxxx1xx0111101x
16710                                                          sshl.  */
16711                                                       return 557;
16712                                                     }
16713                                                 }
16714                                               else
16715                                                 {
16716                                                   /* 33222222222211111111110000000000
16717                                                      10987654321098765432109876543210
16718                                                      xxxxxxxxxx1001xxxxxxx1xx0111101x
16719                                                      fcmeq.  */
16720                                                   return 549;
16721                                                 }
16722                                             }
16723                                           else
16724                                             {
16725                                               if (((word >> 13) & 0x1) == 0)
16726                                                 {
16727                                                   /* 33222222222211111111110000000000
16728                                                      10987654321098765432109876543210
16729                                                      xxxxxxxxxx1010xxxxxxx1xx0111101x
16730                                                      srshl.  */
16731                                                   return 558;
16732                                                 }
16733                                               else
16734                                                 {
16735                                                   if (((word >> 15) & 0x1) == 0)
16736                                                     {
16737                                                       /* 33222222222211111111110000000000
16738                                                          10987654321098765432109876543210
16739                                                          xxxxxxxxxx1011x0xxxxx1xx0111101x
16740                                                          cmgt.  */
16741                                                       return 555;
16742                                                     }
16743                                                   else
16744                                                     {
16745                                                       /* 33222222222211111111110000000000
16746                                                          10987654321098765432109876543210
16747                                                          xxxxxxxxxx1011x1xxxxx1xx0111101x
16748                                                          sqdmulh.  */
16749                                                       return 546;
16750                                                     }
16751                                                 }
16752                                             }
16753                                         }
16754                                     }
16755                                   else
16756                                     {
16757                                       if (((word >> 12) & 0x1) == 0)
16758                                         {
16759                                           if (((word >> 13) & 0x1) == 0)
16760                                             {
16761                                               if (((word >> 14) & 0x1) == 0)
16762                                                 {
16763                                                   /* 33222222222211111111110000000000
16764                                                      10987654321098765432109876543210
16765                                                      xxxxxxxxxx10000xxxxxx1xx011111xx
16766                                                      sub.  */
16767                                                   return 580;
16768                                                 }
16769                                               else
16770                                                 {
16771                                                   /* 33222222222211111111110000000000
16772                                                      10987654321098765432109876543210
16773                                                      xxxxxxxxxx10001xxxxxx1xx011111xx
16774                                                      ushl.  */
16775                                                   return 578;
16776                                                 }
16777                                             }
16778                                           else
16779                                             {
16780                                               if (((word >> 23) & 0x1) == 0)
16781                                                 {
16782                                                   /* 33222222222211111111110000000000
16783                                                      10987654321098765432109876543210
16784                                                      xxxxxxxxxx1001xxxxxxx1x0011111xx
16785                                                      fcmge.  */
16786                                                   return 566;
16787                                                 }
16788                                               else
16789                                                 {
16790                                                   /* 33222222222211111111110000000000
16791                                                      10987654321098765432109876543210
16792                                                      xxxxxxxxxx1001xxxxxxx1x1011111xx
16793                                                      fcmgt.  */
16794                                                   return 572;
16795                                                 }
16796                                             }
16797                                         }
16798                                       else
16799                                         {
16800                                           if (((word >> 13) & 0x1) == 0)
16801                                             {
16802                                               if (((word >> 15) & 0x1) == 0)
16803                                                 {
16804                                                   /* 33222222222211111111110000000000
16805                                                      10987654321098765432109876543210
16806                                                      xxxxxxxxxx1010x0xxxxx1xx011111xx
16807                                                      urshl.  */
16808                                                   return 579;
16809                                                 }
16810                                               else
16811                                                 {
16812                                                   /* 33222222222211111111110000000000
16813                                                      10987654321098765432109876543210
16814                                                      xxxxxxxxxx1010x1xxxxx1xx011111xx
16815                                                      fabd.  */
16816                                                   return 570;
16817                                                 }
16818                                             }
16819                                           else
16820                                             {
16821                                               if (((word >> 15) & 0x1) == 0)
16822                                                 {
16823                                                   /* 33222222222211111111110000000000
16824                                                      10987654321098765432109876543210
16825                                                      xxxxxxxxxx1011x0xxxxx1xx011111xx
16826                                                      cmhi.  */
16827                                                   return 576;
16828                                                 }
16829                                               else
16830                                                 {
16831                                                   /* 33222222222211111111110000000000
16832                                                      10987654321098765432109876543210
16833                                                      xxxxxxxxxx1011x1xxxxx1xx011111xx
16834                                                      sqrdmulh.  */
16835                                                   return 565;
16836                                                 }
16837                                             }
16838                                         }
16839                                     }
16840                                 }
16841                             }
16842                           else
16843                             {
16844                               if (((word >> 28) & 0x1) == 0)
16845                                 {
16846                                   if (((word >> 12) & 0x1) == 0)
16847                                     {
16848                                       if (((word >> 13) & 0x1) == 0)
16849                                         {
16850                                           if (((word >> 14) & 0x1) == 0)
16851                                             {
16852                                               if (((word >> 15) & 0x1) == 0)
16853                                                 {
16854                                                   if (((word >> 29) & 0x1) == 0)
16855                                                     {
16856                                                       /* 33222222222211111111110000000000
16857                                                          10987654321098765432109876543210
16858                                                          xxxxxxxxxx110000xxxxx1xx011100xx
16859                                                          sqadd.  */
16860                                                       return 263;
16861                                                     }
16862                                                   else
16863                                                     {
16864                                                       /* 33222222222211111111110000000000
16865                                                          10987654321098765432109876543210
16866                                                          xxxxxxxxxx110000xxxxx1xx011101xx
16867                                                          uqadd.  */
16868                                                       return 315;
16869                                                     }
16870                                                 }
16871                                               else
16872                                                 {
16873                                                   if (((word >> 29) & 0x1) == 0)
16874                                                     {
16875                                                       /* 33222222222211111111110000000000
16876                                                          10987654321098765432109876543210
16877                                                          xxxxxxxxxx110001xxxxx1xx011100xx
16878                                                          cmtst.  */
16879                                                       return 278;
16880                                                     }
16881                                                   else
16882                                                     {
16883                                                       /* 33222222222211111111110000000000
16884                                                          10987654321098765432109876543210
16885                                                          xxxxxxxxxx110001xxxxx1xx011101xx
16886                                                          cmeq.  */
16887                                                       return 330;
16888                                                     }
16889                                                 }
16890                                             }
16891                                           else
16892                                             {
16893                                               if (((word >> 15) & 0x1) == 0)
16894                                                 {
16895                                                   if (((word >> 29) & 0x1) == 0)
16896                                                     {
16897                                                       /* 33222222222211111111110000000000
16898                                                          10987654321098765432109876543210
16899                                                          xxxxxxxxxx110010xxxxx1xx011100xx
16900                                                          sqshl.  */
16901                                                       return 270;
16902                                                     }
16903                                                   else
16904                                                     {
16905                                                       /* 33222222222211111111110000000000
16906                                                          10987654321098765432109876543210
16907                                                          xxxxxxxxxx110010xxxxx1xx011101xx
16908                                                          uqshl.  */
16909                                                       return 322;
16910                                                     }
16911                                                 }
16912                                               else
16913                                                 {
16914                                                   if (((word >> 23) & 0x1) == 0)
16915                                                     {
16916                                                       /* 33222222222211111111110000000000
16917                                                          10987654321098765432109876543210
16918                                                          xxxxxxxxxx110011xxxxx1x001110xxx
16919                                                          fmla.  */
16920                                                       return 287;
16921                                                     }
16922                                                   else
16923                                                     {
16924                                                       /* 33222222222211111111110000000000
16925                                                          10987654321098765432109876543210
16926                                                          xxxxxxxxxx110011xxxxx1x101110xxx
16927                                                          fmls.  */
16928                                                       return 303;
16929                                                     }
16930                                                 }
16931                                             }
16932                                         }
16933                                       else
16934                                         {
16935                                           if (((word >> 14) & 0x1) == 0)
16936                                             {
16937                                               if (((word >> 15) & 0x1) == 0)
16938                                                 {
16939                                                   if (((word >> 29) & 0x1) == 0)
16940                                                     {
16941                                                       /* 33222222222211111111110000000000
16942                                                          10987654321098765432109876543210
16943                                                          xxxxxxxxxx110100xxxxx1xx011100xx
16944                                                          sqsub.  */
16945                                                       return 266;
16946                                                     }
16947                                                   else
16948                                                     {
16949                                                       /* 33222222222211111111110000000000
16950                                                          10987654321098765432109876543210
16951                                                          xxxxxxxxxx110100xxxxx1xx011101xx
16952                                                          uqsub.  */
16953                                                       return 318;
16954                                                     }
16955                                                 }
16956                                               else
16957                                                 {
16958                                                   if (((word >> 29) & 0x1) == 0)
16959                                                     {
16960                                                       /* 33222222222211111111110000000000
16961                                                          10987654321098765432109876543210
16962                                                          xxxxxxxxxx110101xxxxx1xx011100xx
16963                                                          sminp.  */
16964                                                       return 282;
16965                                                     }
16966                                                   else
16967                                                     {
16968                                                       /* 33222222222211111111110000000000
16969                                                          10987654321098765432109876543210
16970                                                          xxxxxxxxxx110101xxxxx1xx011101xx
16971                                                          uminp.  */
16972                                                       return 334;
16973                                                     }
16974                                                 }
16975                                             }
16976                                           else
16977                                             {
16978                                               if (((word >> 15) & 0x1) == 0)
16979                                                 {
16980                                                   if (((word >> 29) & 0x1) == 0)
16981                                                     {
16982                                                       /* 33222222222211111111110000000000
16983                                                          10987654321098765432109876543210
16984                                                          xxxxxxxxxx110110xxxxx1xx011100xx
16985                                                          smin.  */
16986                                                       return 274;
16987                                                     }
16988                                                   else
16989                                                     {
16990                                                       /* 33222222222211111111110000000000
16991                                                          10987654321098765432109876543210
16992                                                          xxxxxxxxxx110110xxxxx1xx011101xx
16993                                                          umin.  */
16994                                                       return 326;
16995                                                     }
16996                                                 }
16997                                               else
16998                                                 {
16999                                                   if (((word >> 23) & 0x1) == 0)
17000                                                     {
17001                                                       /* 33222222222211111111110000000000
17002                                                          10987654321098765432109876543210
17003                                                          xxxxxxxxxx110111xxxxx1x001110xxx
17004                                                          facge.  */
17005                                                       return 344;
17006                                                     }
17007                                                   else
17008                                                     {
17009                                                       /* 33222222222211111111110000000000
17010                                                          10987654321098765432109876543210
17011                                                          xxxxxxxxxx110111xxxxx1x101110xxx
17012                                                          facgt.  */
17013                                                       return 358;
17014                                                     }
17015                                                 }
17016                                             }
17017                                         }
17018                                     }
17019                                   else
17020                                     {
17021                                       if (((word >> 13) & 0x1) == 0)
17022                                         {
17023                                           if (((word >> 14) & 0x1) == 0)
17024                                             {
17025                                               if (((word >> 15) & 0x1) == 0)
17026                                                 {
17027                                                   if (((word >> 22) & 0x1) == 0)
17028                                                     {
17029                                                       if (((word >> 23) & 0x1) == 0)
17030                                                         {
17031                                                           if (((word >> 29) & 0x1) == 0)
17032                                                             {
17033                                                               /* 33222222222211111111110000000000
17034                                                                  10987654321098765432109876543210
17035                                                                  xxxxxxxxxx111000xxxxx100011100xx
17036                                                                  and.  */
17037                                                               return 299;
17038                                                             }
17039                                                           else
17040                                                             {
17041                                                               /* 33222222222211111111110000000000
17042                                                                  10987654321098765432109876543210
17043                                                                  xxxxxxxxxx111000xxxxx100011101xx
17044                                                                  eor.  */
17045                                                               return 350;
17046                                                             }
17047                                                         }
17048                                                       else
17049                                                         {
17050                                                           if (((word >> 29) & 0x1) == 0)
17051                                                             {
17052                                                               /* 33222222222211111111110000000000
17053                                                                  10987654321098765432109876543210
17054                                                                  xxxxxxxxxx111000xxxxx101011100xx
17055                                                                  orr.  */
17056                                                               return 311;
17057                                                             }
17058                                                           else
17059                                                             {
17060                                                               /* 33222222222211111111110000000000
17061                                                                  10987654321098765432109876543210
17062                                                                  xxxxxxxxxx111000xxxxx101011101xx
17063                                                                  bit.  */
17064                                                               return 362;
17065                                                             }
17066                                                         }
17067                                                     }
17068                                                   else
17069                                                     {
17070                                                       if (((word >> 23) & 0x1) == 0)
17071                                                         {
17072                                                           if (((word >> 29) & 0x1) == 0)
17073                                                             {
17074                                                               /* 33222222222211111111110000000000
17075                                                                  10987654321098765432109876543210
17076                                                                  xxxxxxxxxx111000xxxxx110011100xx
17077                                                                  bic.  */
17078                                                               return 300;
17079                                                             }
17080                                                           else
17081                                                             {
17082                                                               /* 33222222222211111111110000000000
17083                                                                  10987654321098765432109876543210
17084                                                                  xxxxxxxxxx111000xxxxx110011101xx
17085                                                                  bsl.  */
17086                                                               return 351;
17087                                                             }
17088                                                         }
17089                                                       else
17090                                                         {
17091                                                           if (((word >> 29) & 0x1) == 0)
17092                                                             {
17093                                                               /* 33222222222211111111110000000000
17094                                                                  10987654321098765432109876543210
17095                                                                  xxxxxxxxxx111000xxxxx111011100xx
17096                                                                  orn.  */
17097                                                               return 313;
17098                                                             }
17099                                                           else
17100                                                             {
17101                                                               /* 33222222222211111111110000000000
17102                                                                  10987654321098765432109876543210
17103                                                                  xxxxxxxxxx111000xxxxx111011101xx
17104                                                                  bif.  */
17105                                                               return 363;
17106                                                             }
17107                                                         }
17108                                                     }
17109                                                 }
17110                                               else
17111                                                 {
17112                                                   if (((word >> 29) & 0x1) == 0)
17113                                                     {
17114                                                       /* 33222222222211111111110000000000
17115                                                          10987654321098765432109876543210
17116                                                          xxxxxxxxxx111001xxxxx1xx011100xx
17117                                                          mul.  */
17118                                                       return 280;
17119                                                     }
17120                                                   else
17121                                                     {
17122                                                       /* 33222222222211111111110000000000
17123                                                          10987654321098765432109876543210
17124                                                          xxxxxxxxxx111001xxxxx1xx011101xx
17125                                                          pmul.  */
17126                                                       return 332;
17127                                                     }
17128                                                 }
17129                                             }
17130                                           else
17131                                             {
17132                                               if (((word >> 15) & 0x1) == 0)
17133                                                 {
17134                                                   if (((word >> 29) & 0x1) == 0)
17135                                                     {
17136                                                       /* 33222222222211111111110000000000
17137                                                          10987654321098765432109876543210
17138                                                          xxxxxxxxxx111010xxxxx1xx011100xx
17139                                                          sqrshl.  */
17140                                                       return 272;
17141                                                     }
17142                                                   else
17143                                                     {
17144                                                       /* 33222222222211111111110000000000
17145                                                          10987654321098765432109876543210
17146                                                          xxxxxxxxxx111010xxxxx1xx011101xx
17147                                                          uqrshl.  */
17148                                                       return 324;
17149                                                     }
17150                                                 }
17151                                               else
17152                                                 {
17153                                                   if (((word >> 29) & 0x1) == 0)
17154                                                     {
17155                                                       /* 33222222222211111111110000000000
17156                                                          10987654321098765432109876543210
17157                                                          xxxxxxxxxx111011xxxxx1xx011100xx
17158                                                          fmulx.  */
17159                                                       return 291;
17160                                                     }
17161                                                   else
17162                                                     {
17163                                                       /* 33222222222211111111110000000000
17164                                                          10987654321098765432109876543210
17165                                                          xxxxxxxxxx111011xxxxx1xx011101xx
17166                                                          fmul.  */
17167                                                       return 340;
17168                                                     }
17169                                                 }
17170                                             }
17171                                         }
17172                                       else
17173                                         {
17174                                           if (((word >> 14) & 0x1) == 0)
17175                                             {
17176                                               if (((word >> 15) & 0x1) == 0)
17177                                                 {
17178                                                   if (((word >> 29) & 0x1) == 0)
17179                                                     {
17180                                                       /* 33222222222211111111110000000000
17181                                                          10987654321098765432109876543210
17182                                                          xxxxxxxxxx111100xxxxx1xx011100xx
17183                                                          cmge.  */
17184                                                       return 268;
17185                                                     }
17186                                                   else
17187                                                     {
17188                                                       /* 33222222222211111111110000000000
17189                                                          10987654321098765432109876543210
17190                                                          xxxxxxxxxx111100xxxxx1xx011101xx
17191                                                          cmhs.  */
17192                                                       return 320;
17193                                                     }
17194                                                 }
17195                                               else
17196                                                 {
17197                                                   /* 33222222222211111111110000000000
17198                                                      10987654321098765432109876543210
17199                                                      xxxxxxxxxx111101xxxxx1xx01110xxx
17200                                                      addp.  */
17201                                                   return 284;
17202                                                 }
17203                                             }
17204                                           else
17205                                             {
17206                                               if (((word >> 15) & 0x1) == 0)
17207                                                 {
17208                                                   if (((word >> 29) & 0x1) == 0)
17209                                                     {
17210                                                       /* 33222222222211111111110000000000
17211                                                          10987654321098765432109876543210
17212                                                          xxxxxxxxxx111110xxxxx1xx011100xx
17213                                                          saba.  */
17214                                                       return 276;
17215                                                     }
17216                                                   else
17217                                                     {
17218                                                       /* 33222222222211111111110000000000
17219                                                          10987654321098765432109876543210
17220                                                          xxxxxxxxxx111110xxxxx1xx011101xx
17221                                                          uaba.  */
17222                                                       return 328;
17223                                                     }
17224                                                 }
17225                                               else
17226                                                 {
17227                                                   if (((word >> 23) & 0x1) == 0)
17228                                                     {
17229                                                       if (((word >> 29) & 0x1) == 0)
17230                                                         {
17231                                                           /* 33222222222211111111110000000000
17232                                                              10987654321098765432109876543210
17233                                                              xxxxxxxxxx111111xxxxx1x0011100xx
17234                                                              frecps.  */
17235                                                           return 297;
17236                                                         }
17237                                                       else
17238                                                         {
17239                                                           /* 33222222222211111111110000000000
17240                                                              10987654321098765432109876543210
17241                                                              xxxxxxxxxx111111xxxxx1x0011101xx
17242                                                              fdiv.  */
17243                                                           return 348;
17244                                                         }
17245                                                     }
17246                                                   else
17247                                                     {
17248                                                       /* 33222222222211111111110000000000
17249                                                          10987654321098765432109876543210
17250                                                          xxxxxxxxxx111111xxxxx1x101110xxx
17251                                                          frsqrts.  */
17252                                                       return 309;
17253                                                     }
17254                                                 }
17255                                             }
17256                                         }
17257                                     }
17258                                 }
17259                               else
17260                                 {
17261                                   if (((word >> 29) & 0x1) == 0)
17262                                     {
17263                                       if (((word >> 30) & 0x1) == 0)
17264                                         {
17265                                           /* 33222222222211111111110000000000
17266                                              10987654321098765432109876543210
17267                                              xxxxxxxxxx11xxxxxxxxx1xx0111100x
17268                                              fcsel.  */
17269                                           return 850;
17270                                         }
17271                                       else
17272                                         {
17273                                           if (((word >> 12) & 0x1) == 0)
17274                                             {
17275                                               if (((word >> 13) & 0x1) == 0)
17276                                                 {
17277                                                   if (((word >> 14) & 0x1) == 0)
17278                                                     {
17279                                                       if (((word >> 15) & 0x1) == 0)
17280                                                         {
17281                                                           /* 33222222222211111111110000000000
17282                                                              10987654321098765432109876543210
17283                                                              xxxxxxxxxx110000xxxxx1xx0111101x
17284                                                              sqadd.  */
17285                                                           return 542;
17286                                                         }
17287                                                       else
17288                                                         {
17289                                                           /* 33222222222211111111110000000000
17290                                                              10987654321098765432109876543210
17291                                                              xxxxxxxxxx110001xxxxx1xx0111101x
17292                                                              cmtst.  */
17293                                                           return 560;
17294                                                         }
17295                                                     }
17296                                                   else
17297                                                     {
17298                                                       /* 33222222222211111111110000000000
17299                                                          10987654321098765432109876543210
17300                                                          xxxxxxxxxx11001xxxxxx1xx0111101x
17301                                                          sqshl.  */
17302                                                       return 544;
17303                                                     }
17304                                                 }
17305                                               else
17306                                                 {
17307                                                   /* 33222222222211111111110000000000
17308                                                      10987654321098765432109876543210
17309                                                      xxxxxxxxxx1101xxxxxxx1xx0111101x
17310                                                      sqsub.  */
17311                                                   return 543;
17312                                                 }
17313                                             }
17314                                           else
17315                                             {
17316                                               if (((word >> 13) & 0x1) == 0)
17317                                                 {
17318                                                   if (((word >> 15) & 0x1) == 0)
17319                                                     {
17320                                                       /* 33222222222211111111110000000000
17321                                                          10987654321098765432109876543210
17322                                                          xxxxxxxxxx1110x0xxxxx1xx0111101x
17323                                                          sqrshl.  */
17324                                                       return 545;
17325                                                     }
17326                                                   else
17327                                                     {
17328                                                       /* 33222222222211111111110000000000
17329                                                          10987654321098765432109876543210
17330                                                          xxxxxxxxxx1110x1xxxxx1xx0111101x
17331                                                          fmulx.  */
17332                                                       return 547;
17333                                                     }
17334                                                 }
17335                                               else
17336                                                 {
17337                                                   if (((word >> 14) & 0x1) == 0)
17338                                                     {
17339                                                       /* 33222222222211111111110000000000
17340                                                          10987654321098765432109876543210
17341                                                          xxxxxxxxxx11110xxxxxx1xx0111101x
17342                                                          cmge.  */
17343                                                       return 556;
17344                                                     }
17345                                                   else
17346                                                     {
17347                                                       if (((word >> 23) & 0x1) == 0)
17348                                                         {
17349                                                           /* 33222222222211111111110000000000
17350                                                              10987654321098765432109876543210
17351                                                              xxxxxxxxxx11111xxxxxx1x00111101x
17352                                                              frecps.  */
17353                                                           return 551;
17354                                                         }
17355                                                       else
17356                                                         {
17357                                                           /* 33222222222211111111110000000000
17358                                                              10987654321098765432109876543210
17359                                                              xxxxxxxxxx11111xxxxxx1x10111101x
17360                                                              frsqrts.  */
17361                                                           return 553;
17362                                                         }
17363                                                     }
17364                                                 }
17365                                             }
17366                                         }
17367                                     }
17368                                   else
17369                                     {
17370                                       if (((word >> 12) & 0x1) == 0)
17371                                         {
17372                                           if (((word >> 13) & 0x1) == 0)
17373                                             {
17374                                               if (((word >> 14) & 0x1) == 0)
17375                                                 {
17376                                                   if (((word >> 15) & 0x1) == 0)
17377                                                     {
17378                                                       /* 33222222222211111111110000000000
17379                                                          10987654321098765432109876543210
17380                                                          xxxxxxxxxx110000xxxxx1xx011111xx
17381                                                          uqadd.  */
17382                                                       return 561;
17383                                                     }
17384                                                   else
17385                                                     {
17386                                                       /* 33222222222211111111110000000000
17387                                                          10987654321098765432109876543210
17388                                                          xxxxxxxxxx110001xxxxx1xx011111xx
17389                                                          cmeq.  */
17390                                                       return 581;
17391                                                     }
17392                                                 }
17393                                               else
17394                                                 {
17395                                                   /* 33222222222211111111110000000000
17396                                                      10987654321098765432109876543210
17397                                                      xxxxxxxxxx11001xxxxxx1xx011111xx
17398                                                      uqshl.  */
17399                                                   return 563;
17400                                                 }
17401                                             }
17402                                           else
17403                                             {
17404                                               if (((word >> 14) & 0x1) == 0)
17405                                                 {
17406                                                   /* 33222222222211111111110000000000
17407                                                      10987654321098765432109876543210
17408                                                      xxxxxxxxxx11010xxxxxx1xx011111xx
17409                                                      uqsub.  */
17410                                                   return 562;
17411                                                 }
17412                                               else
17413                                                 {
17414                                                   if (((word >> 23) & 0x1) == 0)
17415                                                     {
17416                                                       /* 33222222222211111111110000000000
17417                                                          10987654321098765432109876543210
17418                                                          xxxxxxxxxx11011xxxxxx1x0011111xx
17419                                                          facge.  */
17420                                                       return 568;
17421                                                     }
17422                                                   else
17423                                                     {
17424                                                       /* 33222222222211111111110000000000
17425                                                          10987654321098765432109876543210
17426                                                          xxxxxxxxxx11011xxxxxx1x1011111xx
17427                                                          facgt.  */
17428                                                       return 574;
17429                                                     }
17430                                                 }
17431                                             }
17432                                         }
17433                                       else
17434                                         {
17435                                           if (((word >> 13) & 0x1) == 0)
17436                                             {
17437                                               /* 33222222222211111111110000000000
17438                                                  10987654321098765432109876543210
17439                                                  xxxxxxxxxx1110xxxxxxx1xx011111xx
17440                                                  uqrshl.  */
17441                                               return 564;
17442                                             }
17443                                           else
17444                                             {
17445                                               /* 33222222222211111111110000000000
17446                                                  10987654321098765432109876543210
17447                                                  xxxxxxxxxx1111xxxxxxx1xx011111xx
17448                                                  cmhs.  */
17449                                               return 577;
17450                                             }
17451                                         }
17452                                     }
17453                                 }
17454                             }
17455                         }
17456                     }
17457                 }
17458               else
17459                 {
17460                   if (((word >> 15) & 0x1) == 0)
17461                     {
17462                       if (((word >> 28) & 0x1) == 0)
17463                         {
17464                           if (((word >> 10) & 0x1) == 0)
17465                             {
17466                               if (((word >> 12) & 0x1) == 0)
17467                                 {
17468                                   if (((word >> 13) & 0x1) == 0)
17469                                     {
17470                                       if (((word >> 14) & 0x1) == 0)
17471                                         {
17472                                           /* 33222222222211111111110000000000
17473                                              10987654321098765432109876543210
17474                                              xxxxxxxxxx0x0000xxxxxxxx11110xxx
17475                                              mla.  */
17476                                           return 117;
17477                                         }
17478                                       else
17479                                         {
17480                                           /* 33222222222211111111110000000000
17481                                              10987654321098765432109876543210
17482                                              xxxxxxxxxx0x0010xxxxxxxx11110xxx
17483                                              mls.  */
17484                                           return 120;
17485                                         }
17486                                     }
17487                                   else
17488                                     {
17489                                       if (((word >> 14) & 0x1) == 0)
17490                                         {
17491                                           if (((word >> 29) & 0x1) == 0)
17492                                             {
17493                                               if (((word >> 30) & 0x1) == 0)
17494                                                 {
17495                                                   /* 33222222222211111111110000000000
17496                                                      10987654321098765432109876543210
17497                                                      xxxxxxxxxx0x0100xxxxxxxx1111000x
17498                                                      smlal.  */
17499                                                   return 96;
17500                                                 }
17501                                               else
17502                                                 {
17503                                                   /* 33222222222211111111110000000000
17504                                                      10987654321098765432109876543210
17505                                                      xxxxxxxxxx0x0100xxxxxxxx1111001x
17506                                                      smlal2.  */
17507                                                   return 97;
17508                                                 }
17509                                             }
17510                                           else
17511                                             {
17512                                               if (((word >> 30) & 0x1) == 0)
17513                                                 {
17514                                                   /* 33222222222211111111110000000000
17515                                                      10987654321098765432109876543210
17516                                                      xxxxxxxxxx0x0100xxxxxxxx1111010x
17517                                                      umlal.  */
17518                                                   return 118;
17519                                                 }
17520                                               else
17521                                                 {
17522                                                   /* 33222222222211111111110000000000
17523                                                      10987654321098765432109876543210
17524                                                      xxxxxxxxxx0x0100xxxxxxxx1111011x
17525                                                      umlal2.  */
17526                                                   return 119;
17527                                                 }
17528                                             }
17529                                         }
17530                                       else
17531                                         {
17532                                           if (((word >> 29) & 0x1) == 0)
17533                                             {
17534                                               if (((word >> 30) & 0x1) == 0)
17535                                                 {
17536                                                   /* 33222222222211111111110000000000
17537                                                      10987654321098765432109876543210
17538                                                      xxxxxxxxxx0x0110xxxxxxxx1111000x
17539                                                      smlsl.  */
17540                                                   return 100;
17541                                                 }
17542                                               else
17543                                                 {
17544                                                   /* 33222222222211111111110000000000
17545                                                      10987654321098765432109876543210
17546                                                      xxxxxxxxxx0x0110xxxxxxxx1111001x
17547                                                      smlsl2.  */
17548                                                   return 101;
17549                                                 }
17550                                             }
17551                                           else
17552                                             {
17553                                               if (((word >> 30) & 0x1) == 0)
17554                                                 {
17555                                                   /* 33222222222211111111110000000000
17556                                                      10987654321098765432109876543210
17557                                                      xxxxxxxxxx0x0110xxxxxxxx1111010x
17558                                                      umlsl.  */
17559                                                   return 121;
17560                                                 }
17561                                               else
17562                                                 {
17563                                                   /* 33222222222211111111110000000000
17564                                                      10987654321098765432109876543210
17565                                                      xxxxxxxxxx0x0110xxxxxxxx1111011x
17566                                                      umlsl2.  */
17567                                                   return 122;
17568                                                 }
17569                                             }
17570                                         }
17571                                     }
17572                                 }
17573                               else
17574                                 {
17575                                   if (((word >> 29) & 0x1) == 0)
17576                                     {
17577                                       if (((word >> 13) & 0x1) == 0)
17578                                         {
17579                                           if (((word >> 14) & 0x1) == 0)
17580                                             {
17581                                               if (((word >> 23) & 0x1) == 0)
17582                                                 {
17583                                                   /* 33222222222211111111110000000000
17584                                                      10987654321098765432109876543210
17585                                                      xxxxxxxxxx0x1000xxxxxxx0111100xx
17586                                                      fmla.  */
17587                                                   return 112;
17588                                                 }
17589                                               else
17590                                                 {
17591                                                   /* 33222222222211111111110000000000
17592                                                      10987654321098765432109876543210
17593                                                      xxxxxxxxxx0x1000xxxxxxx1111100xx
17594                                                      fmla.  */
17595                                                   return 111;
17596                                                 }
17597                                             }
17598                                           else
17599                                             {
17600                                               if (((word >> 23) & 0x1) == 0)
17601                                                 {
17602                                                   /* 33222222222211111111110000000000
17603                                                      10987654321098765432109876543210
17604                                                      xxxxxxxxxx0x1010xxxxxxx0111100xx
17605                                                      fmls.  */
17606                                                   return 114;
17607                                                 }
17608                                               else
17609                                                 {
17610                                                   /* 33222222222211111111110000000000
17611                                                      10987654321098765432109876543210
17612                                                      xxxxxxxxxx0x1010xxxxxxx1111100xx
17613                                                      fmls.  */
17614                                                   return 113;
17615                                                 }
17616                                             }
17617                                         }
17618                                       else
17619                                         {
17620                                           if (((word >> 14) & 0x1) == 0)
17621                                             {
17622                                               if (((word >> 30) & 0x1) == 0)
17623                                                 {
17624                                                   /* 33222222222211111111110000000000
17625                                                      10987654321098765432109876543210
17626                                                      xxxxxxxxxx0x1100xxxxxxxx1111000x
17627                                                      sqdmlal.  */
17628                                                   return 98;
17629                                                 }
17630                                               else
17631                                                 {
17632                                                   /* 33222222222211111111110000000000
17633                                                      10987654321098765432109876543210
17634                                                      xxxxxxxxxx0x1100xxxxxxxx1111001x
17635                                                      sqdmlal2.  */
17636                                                   return 99;
17637                                                 }
17638                                             }
17639                                           else
17640                                             {
17641                                               if (((word >> 30) & 0x1) == 0)
17642                                                 {
17643                                                   /* 33222222222211111111110000000000
17644                                                      10987654321098765432109876543210
17645                                                      xxxxxxxxxx0x1110xxxxxxxx1111000x
17646                                                      sqdmlsl.  */
17647                                                   return 102;
17648                                                 }
17649                                               else
17650                                                 {
17651                                                   /* 33222222222211111111110000000000
17652                                                      10987654321098765432109876543210
17653                                                      xxxxxxxxxx0x1110xxxxxxxx1111001x
17654                                                      sqdmlsl2.  */
17655                                                   return 103;
17656                                                 }
17657                                             }
17658                                         }
17659                                     }
17660                                   else
17661                                     {
17662                                       /* 33222222222211111111110000000000
17663                                          10987654321098765432109876543210
17664                                          xxxxxxxxxx0x1xx0xxxxxxxx111101xx
17665                                          fcmla.  */
17666                                       return 129;
17667                                     }
17668                                 }
17669                             }
17670                           else
17671                             {
17672                               if (((word >> 12) & 0x1) == 0)
17673                                 {
17674                                   if (((word >> 29) & 0x1) == 0)
17675                                     {
17676                                       /* 33222222222211111111110000000000
17677                                          10987654321098765432109876543210
17678                                          xxxxxxxxxx1x0xx0xxxxxxxx111100xx
17679                                          movi.  */
17680                                       return 131;
17681                                     }
17682                                   else
17683                                     {
17684                                       /* 33222222222211111111110000000000
17685                                          10987654321098765432109876543210
17686                                          xxxxxxxxxx1x0xx0xxxxxxxx111101xx
17687                                          mvni.  */
17688                                       return 139;
17689                                     }
17690                                 }
17691                               else
17692                                 {
17693                                   if (((word >> 29) & 0x1) == 0)
17694                                     {
17695                                       /* 33222222222211111111110000000000
17696                                          10987654321098765432109876543210
17697                                          xxxxxxxxxx1x1xx0xxxxxxxx111100xx
17698                                          orr.  */
17699                                       return 132;
17700                                     }
17701                                   else
17702                                     {
17703                                       /* 33222222222211111111110000000000
17704                                          10987654321098765432109876543210
17705                                          xxxxxxxxxx1x1xx0xxxxxxxx111101xx
17706                                          bic.  */
17707                                       return 140;
17708                                     }
17709                                 }
17710                             }
17711                         }
17712                       else
17713                         {
17714                           if (((word >> 29) & 0x1) == 0)
17715                             {
17716                               if (((word >> 30) & 0x1) == 0)
17717                                 {
17718                                   if (((word >> 21) & 0x1) == 0)
17719                                     {
17720                                       /* 33222222222211111111110000000000
17721                                          10987654321098765432109876543210
17722                                          xxxxxxxxxxxxxxx0xxxxx0xx1111100x
17723                                          fmadd.  */
17724                                       return 840;
17725                                     }
17726                                   else
17727                                     {
17728                                       /* 33222222222211111111110000000000
17729                                          10987654321098765432109876543210
17730                                          xxxxxxxxxxxxxxx0xxxxx1xx1111100x
17731                                          fnmadd.  */
17732                                       return 844;
17733                                     }
17734                                 }
17735                               else
17736                                 {
17737                                   if (((word >> 10) & 0x1) == 0)
17738                                     {
17739                                       if (((word >> 13) & 0x1) == 0)
17740                                         {
17741                                           if (((word >> 14) & 0x1) == 0)
17742                                             {
17743                                               if (((word >> 23) & 0x1) == 0)
17744                                                 {
17745                                                   /* 33222222222211111111110000000000
17746                                                      10987654321098765432109876543210
17747                                                      xxxxxxxxxx0xx000xxxxxxx01111101x
17748                                                      fmla.  */
17749                                                   return 425;
17750                                                 }
17751                                               else
17752                                                 {
17753                                                   /* 33222222222211111111110000000000
17754                                                      10987654321098765432109876543210
17755                                                      xxxxxxxxxx0xx000xxxxxxx11111101x
17756                                                      fmla.  */
17757                                                   return 424;
17758                                                 }
17759                                             }
17760                                           else
17761                                             {
17762                                               if (((word >> 23) & 0x1) == 0)
17763                                                 {
17764                                                   /* 33222222222211111111110000000000
17765                                                      10987654321098765432109876543210
17766                                                      xxxxxxxxxx0xx010xxxxxxx01111101x
17767                                                      fmls.  */
17768                                                   return 427;
17769                                                 }
17770                                               else
17771                                                 {
17772                                                   /* 33222222222211111111110000000000
17773                                                      10987654321098765432109876543210
17774                                                      xxxxxxxxxx0xx010xxxxxxx11111101x
17775                                                      fmls.  */
17776                                                   return 426;
17777                                                 }
17778                                             }
17779                                         }
17780                                       else
17781                                         {
17782                                           if (((word >> 14) & 0x1) == 0)
17783                                             {
17784                                               /* 33222222222211111111110000000000
17785                                                  10987654321098765432109876543210
17786                                                  xxxxxxxxxx0xx100xxxxxxxx1111101x
17787                                                  sqdmlal.  */
17788                                               return 419;
17789                                             }
17790                                           else
17791                                             {
17792                                               /* 33222222222211111111110000000000
17793                                                  10987654321098765432109876543210
17794                                                  xxxxxxxxxx0xx110xxxxxxxx1111101x
17795                                                  sqdmlsl.  */
17796                                               return 420;
17797                                             }
17798                                         }
17799                                     }
17800                                   else
17801                                     {
17802                                       if (((word >> 12) & 0x1) == 0)
17803                                         {
17804                                           if (((word >> 13) & 0x1) == 0)
17805                                             {
17806                                               /* 33222222222211111111110000000000
17807                                                  10987654321098765432109876543210
17808                                                  xxxxxxxxxx1x00x0xxxxxxxx1111101x
17809                                                  sshr.  */
17810                                               return 584;
17811                                             }
17812                                           else
17813                                             {
17814                                               /* 33222222222211111111110000000000
17815                                                  10987654321098765432109876543210
17816                                                  xxxxxxxxxx1x01x0xxxxxxxx1111101x
17817                                                  srshr.  */
17818                                               return 586;
17819                                             }
17820                                         }
17821                                       else
17822                                         {
17823                                           if (((word >> 13) & 0x1) == 0)
17824                                             {
17825                                               if (((word >> 14) & 0x1) == 0)
17826                                                 {
17827                                                   /* 33222222222211111111110000000000
17828                                                      10987654321098765432109876543210
17829                                                      xxxxxxxxxx1x1000xxxxxxxx1111101x
17830                                                      ssra.  */
17831                                                   return 585;
17832                                                 }
17833                                               else
17834                                                 {
17835                                                   /* 33222222222211111111110000000000
17836                                                      10987654321098765432109876543210
17837                                                      xxxxxxxxxx1x1010xxxxxxxx1111101x
17838                                                      shl.  */
17839                                                   return 588;
17840                                                 }
17841                                             }
17842                                           else
17843                                             {
17844                                               if (((word >> 14) & 0x1) == 0)
17845                                                 {
17846                                                   /* 33222222222211111111110000000000
17847                                                      10987654321098765432109876543210
17848                                                      xxxxxxxxxx1x1100xxxxxxxx1111101x
17849                                                      srsra.  */
17850                                                   return 587;
17851                                                 }
17852                                               else
17853                                                 {
17854                                                   /* 33222222222211111111110000000000
17855                                                      10987654321098765432109876543210
17856                                                      xxxxxxxxxx1x1110xxxxxxxx1111101x
17857                                                      sqshl.  */
17858                                                   return 589;
17859                                                 }
17860                                             }
17861                                         }
17862                                     }
17863                                 }
17864                             }
17865                           else
17866                             {
17867                               if (((word >> 12) & 0x1) == 0)
17868                                 {
17869                                   if (((word >> 13) & 0x1) == 0)
17870                                     {
17871                                       if (((word >> 14) & 0x1) == 0)
17872                                         {
17873                                           /* 33222222222211111111110000000000
17874                                              10987654321098765432109876543210
17875                                              xxxxxxxxxxxx0000xxxxxxxx111111xx
17876                                              ushr.  */
17877                                           return 596;
17878                                         }
17879                                       else
17880                                         {
17881                                           /* 33222222222211111111110000000000
17882                                              10987654321098765432109876543210
17883                                              xxxxxxxxxxxx0010xxxxxxxx111111xx
17884                                              sri.  */
17885                                           return 600;
17886                                         }
17887                                     }
17888                                   else
17889                                     {
17890                                       if (((word >> 14) & 0x1) == 0)
17891                                         {
17892                                           /* 33222222222211111111110000000000
17893                                              10987654321098765432109876543210
17894                                              xxxxxxxxxxxx0100xxxxxxxx111111xx
17895                                              urshr.  */
17896                                           return 598;
17897                                         }
17898                                       else
17899                                         {
17900                                           /* 33222222222211111111110000000000
17901                                              10987654321098765432109876543210
17902                                              xxxxxxxxxxxx0110xxxxxxxx111111xx
17903                                              sqshlu.  */
17904                                           return 602;
17905                                         }
17906                                     }
17907                                 }
17908                               else
17909                                 {
17910                                   if (((word >> 13) & 0x1) == 0)
17911                                     {
17912                                       if (((word >> 14) & 0x1) == 0)
17913                                         {
17914                                           /* 33222222222211111111110000000000
17915                                              10987654321098765432109876543210
17916                                              xxxxxxxxxxxx1000xxxxxxxx111111xx
17917                                              usra.  */
17918                                           return 597;
17919                                         }
17920                                       else
17921                                         {
17922                                           /* 33222222222211111111110000000000
17923                                              10987654321098765432109876543210
17924                                              xxxxxxxxxxxx1010xxxxxxxx111111xx
17925                                              sli.  */
17926                                           return 601;
17927                                         }
17928                                     }
17929                                   else
17930                                     {
17931                                       if (((word >> 14) & 0x1) == 0)
17932                                         {
17933                                           /* 33222222222211111111110000000000
17934                                              10987654321098765432109876543210
17935                                              xxxxxxxxxxxx1100xxxxxxxx111111xx
17936                                              ursra.  */
17937                                           return 599;
17938                                         }
17939                                       else
17940                                         {
17941                                           /* 33222222222211111111110000000000
17942                                              10987654321098765432109876543210
17943                                              xxxxxxxxxxxx1110xxxxxxxx111111xx
17944                                              uqshl.  */
17945                                           return 603;
17946                                         }
17947                                     }
17948                                 }
17949                             }
17950                         }
17951                     }
17952                   else
17953                     {
17954                       if (((word >> 28) & 0x1) == 0)
17955                         {
17956                           if (((word >> 14) & 0x1) == 0)
17957                             {
17958                               if (((word >> 10) & 0x1) == 0)
17959                                 {
17960                                   if (((word >> 12) & 0x1) == 0)
17961                                     {
17962                                       if (((word >> 13) & 0x1) == 0)
17963                                         {
17964                                           /* 33222222222211111111110000000000
17965                                              10987654321098765432109876543210
17966                                              xxxxxxxxxx0x0001xxxxxxxx11110xxx
17967                                              mul.  */
17968                                           return 104;
17969                                         }
17970                                       else
17971                                         {
17972                                           if (((word >> 29) & 0x1) == 0)
17973                                             {
17974                                               if (((word >> 30) & 0x1) == 0)
17975                                                 {
17976                                                   /* 33222222222211111111110000000000
17977                                                      10987654321098765432109876543210
17978                                                      xxxxxxxxxx0x0101xxxxxxxx1111000x
17979                                                      smull.  */
17980                                                   return 105;
17981                                                 }
17982                                               else
17983                                                 {
17984                                                   /* 33222222222211111111110000000000
17985                                                      10987654321098765432109876543210
17986                                                      xxxxxxxxxx0x0101xxxxxxxx1111001x
17987                                                      smull2.  */
17988                                                   return 106;
17989                                                 }
17990                                             }
17991                                           else
17992                                             {
17993                                               if (((word >> 30) & 0x1) == 0)
17994                                                 {
17995                                                   /* 33222222222211111111110000000000
17996                                                      10987654321098765432109876543210
17997                                                      xxxxxxxxxx0x0101xxxxxxxx1111010x
17998                                                      umull.  */
17999                                                   return 123;
18000                                                 }
18001                                               else
18002                                                 {
18003                                                   /* 33222222222211111111110000000000
18004                                                      10987654321098765432109876543210
18005                                                      xxxxxxxxxx0x0101xxxxxxxx1111011x
18006                                                      umull2.  */
18007                                                   return 124;
18008                                                 }
18009                                             }
18010                                         }
18011                                     }
18012                                   else
18013                                     {
18014                                       if (((word >> 13) & 0x1) == 0)
18015                                         {
18016                                           if (((word >> 23) & 0x1) == 0)
18017                                             {
18018                                               if (((word >> 29) & 0x1) == 0)
18019                                                 {
18020                                                   /* 33222222222211111111110000000000
18021                                                      10987654321098765432109876543210
18022                                                      xxxxxxxxxx0x1001xxxxxxx0111100xx
18023                                                      fmul.  */
18024                                                   return 116;
18025                                                 }
18026                                               else
18027                                                 {
18028                                                   /* 33222222222211111111110000000000
18029                                                      10987654321098765432109876543210
18030                                                      xxxxxxxxxx0x1001xxxxxxx0111101xx
18031                                                      fmulx.  */
18032                                                   return 126;
18033                                                 }
18034                                             }
18035                                           else
18036                                             {
18037                                               if (((word >> 29) & 0x1) == 0)
18038                                                 {
18039                                                   /* 33222222222211111111110000000000
18040                                                      10987654321098765432109876543210
18041                                                      xxxxxxxxxx0x1001xxxxxxx1111100xx
18042                                                      fmul.  */
18043                                                   return 115;
18044                                                 }
18045                                               else
18046                                                 {
18047                                                   /* 33222222222211111111110000000000
18048                                                      10987654321098765432109876543210
18049                                                      xxxxxxxxxx0x1001xxxxxxx1111101xx
18050                                                      fmulx.  */
18051                                                   return 125;
18052                                                 }
18053                                             }
18054                                         }
18055                                       else
18056                                         {
18057                                           if (((word >> 30) & 0x1) == 0)
18058                                             {
18059                                               /* 33222222222211111111110000000000
18060                                                  10987654321098765432109876543210
18061                                                  xxxxxxxxxx0x1101xxxxxxxx11110x0x
18062                                                  sqdmull.  */
18063                                               return 107;
18064                                             }
18065                                           else
18066                                             {
18067                                               /* 33222222222211111111110000000000
18068                                                  10987654321098765432109876543210
18069                                                  xxxxxxxxxx0x1101xxxxxxxx11110x1x
18070                                                  sqdmull2.  */
18071                                               return 108;
18072                                             }
18073                                         }
18074                                     }
18075                                 }
18076                               else
18077                                 {
18078                                   if (((word >> 11) & 0x1) == 0)
18079                                     {
18080                                       if (((word >> 12) & 0x1) == 0)
18081                                         {
18082                                           if (((word >> 29) & 0x1) == 0)
18083                                             {
18084                                               /* 33222222222211111111110000000000
18085                                                  10987654321098765432109876543210
18086                                                  xxxxxxxxxx100x01xxxxxxxx111100xx
18087                                                  movi.  */
18088                                               return 133;
18089                                             }
18090                                           else
18091                                             {
18092                                               /* 33222222222211111111110000000000
18093                                                  10987654321098765432109876543210
18094                                                  xxxxxxxxxx100x01xxxxxxxx111101xx
18095                                                  mvni.  */
18096                                               return 141;
18097                                             }
18098                                         }
18099                                       else
18100                                         {
18101                                           if (((word >> 29) & 0x1) == 0)
18102                                             {
18103                                               /* 33222222222211111111110000000000
18104                                                  10987654321098765432109876543210
18105                                                  xxxxxxxxxx101x01xxxxxxxx111100xx
18106                                                  orr.  */
18107                                               return 134;
18108                                             }
18109                                           else
18110                                             {
18111                                               /* 33222222222211111111110000000000
18112                                                  10987654321098765432109876543210
18113                                                  xxxxxxxxxx101x01xxxxxxxx111101xx
18114                                                  bic.  */
18115                                               return 142;
18116                                             }
18117                                         }
18118                                     }
18119                                   else
18120                                     {
18121                                       if (((word >> 12) & 0x1) == 0)
18122                                         {
18123                                           if (((word >> 29) & 0x1) == 0)
18124                                             {
18125                                               if (((word >> 30) & 0x1) == 0)
18126                                                 {
18127                                                   /* 33222222222211111111110000000000
18128                                                      10987654321098765432109876543210
18129                                                      xxxxxxxxxx110x01xxxxxxxx1111000x
18130                                                      rshrn.  */
18131                                                   return 376;
18132                                                 }
18133                                               else
18134                                                 {
18135                                                   /* 33222222222211111111110000000000
18136                                                      10987654321098765432109876543210
18137                                                      xxxxxxxxxx110x01xxxxxxxx1111001x
18138                                                      rshrn2.  */
18139                                                   return 377;
18140                                                 }
18141                                             }
18142                                           else
18143                                             {
18144                                               if (((word >> 30) & 0x1) == 0)
18145                                                 {
18146                                                   /* 33222222222211111111110000000000
18147                                                      10987654321098765432109876543210
18148                                                      xxxxxxxxxx110x01xxxxxxxx1111010x
18149                                                      sqrshrun.  */
18150                                                   return 400;
18151                                                 }
18152                                               else
18153                                                 {
18154                                                   /* 33222222222211111111110000000000
18155                                                      10987654321098765432109876543210
18156                                                      xxxxxxxxxx110x01xxxxxxxx1111011x
18157                                                      sqrshrun2.  */
18158                                                   return 401;
18159                                                 }
18160                                             }
18161                                         }
18162                                       else
18163                                         {
18164                                           if (((word >> 29) & 0x1) == 0)
18165                                             {
18166                                               if (((word >> 30) & 0x1) == 0)
18167                                                 {
18168                                                   /* 33222222222211111111110000000000
18169                                                      10987654321098765432109876543210
18170                                                      xxxxxxxxxx111x01xxxxxxxx1111000x
18171                                                      sqrshrn.  */
18172                                                   return 380;
18173                                                 }
18174                                               else
18175                                                 {
18176                                                   /* 33222222222211111111110000000000
18177                                                      10987654321098765432109876543210
18178                                                      xxxxxxxxxx111x01xxxxxxxx1111001x
18179                                                      sqrshrn2.  */
18180                                                   return 381;
18181                                                 }
18182                                             }
18183                                           else
18184                                             {
18185                                               if (((word >> 30) & 0x1) == 0)
18186                                                 {
18187                                                   /* 33222222222211111111110000000000
18188                                                      10987654321098765432109876543210
18189                                                      xxxxxxxxxx111x01xxxxxxxx1111010x
18190                                                      uqrshrn.  */
18191                                                   return 404;
18192                                                 }
18193                                               else
18194                                                 {
18195                                                   /* 33222222222211111111110000000000
18196                                                      10987654321098765432109876543210
18197                                                      xxxxxxxxxx111x01xxxxxxxx1111011x
18198                                                      uqrshrn2.  */
18199                                                   return 405;
18200                                                 }
18201                                             }
18202                                         }
18203                                     }
18204                                 }
18205                             }
18206                           else
18207                             {
18208                               if (((word >> 13) & 0x1) == 0)
18209                                 {
18210                                   if (((word >> 10) & 0x1) == 0)
18211                                     {
18212                                       if (((word >> 12) & 0x1) == 0)
18213                                         {
18214                                           /* 33222222222211111111110000000000
18215                                              10987654321098765432109876543210
18216                                              xxxxxxxxxx0x0011xxxxxxxx11110xxx
18217                                              sqdmulh.  */
18218                                           return 109;
18219                                         }
18220                                       else
18221                                         {
18222                                           if (((word >> 29) & 0x1) == 0)
18223                                             {
18224                                               /* 33222222222211111111110000000000
18225                                                  10987654321098765432109876543210
18226                                                  xxxxxxxxxx0x1011xxxxxxxx111100xx
18227                                                  sqrdmulh.  */
18228                                               return 110;
18229                                             }
18230                                           else
18231                                             {
18232                                               /* 33222222222211111111110000000000
18233                                                  10987654321098765432109876543210
18234                                                  xxxxxxxxxx0x1011xxxxxxxx111101xx
18235                                                  sqrdmlah.  */
18236                                               return 127;
18237                                             }
18238                                         }
18239                                     }
18240                                   else
18241                                     {
18242                                       if (((word >> 29) & 0x1) == 0)
18243                                         {
18244                                           /* 33222222222211111111110000000000
18245                                              10987654321098765432109876543210
18246                                              xxxxxxxxxx1xx011xxxxxxxx111100xx
18247                                              movi.  */
18248                                           return 135;
18249                                         }
18250                                       else
18251                                         {
18252                                           /* 33222222222211111111110000000000
18253                                              10987654321098765432109876543210
18254                                              xxxxxxxxxx1xx011xxxxxxxx111101xx
18255                                              mvni.  */
18256                                           return 143;
18257                                         }
18258                                     }
18259                                 }
18260                               else
18261                                 {
18262                                   if (((word >> 12) & 0x1) == 0)
18263                                     {
18264                                       if (((word >> 29) & 0x1) == 0)
18265                                         {
18266                                           /* 33222222222211111111110000000000
18267                                              10987654321098765432109876543210
18268                                              xxxxxxxxxxxx0111xxxxxxxx111100xx
18269                                              movi.  */
18270                                           return 136;
18271                                         }
18272                                       else
18273                                         {
18274                                           /* 33222222222211111111110000000000
18275                                              10987654321098765432109876543210
18276                                              xxxxxxxxxxxx0111xxxxxxxx111101xx
18277                                              movi.  */
18278                                           return 144;
18279                                         }
18280                                     }
18281                                   else
18282                                     {
18283                                       if (((word >> 10) & 0x1) == 0)
18284                                         {
18285                                           /* 33222222222211111111110000000000
18286                                              10987654321098765432109876543210
18287                                              xxxxxxxxxx0x1111xxxxxxxx11110xxx
18288                                              sqrdmlsh.  */
18289                                           return 128;
18290                                         }
18291                                       else
18292                                         {
18293                                           if (((word >> 11) & 0x1) == 0)
18294                                             {
18295                                               if (((word >> 29) & 0x1) == 0)
18296                                                 {
18297                                                   /* 33222222222211111111110000000000
18298                                                      10987654321098765432109876543210
18299                                                      xxxxxxxxxx101111xxxxxxxx111100xx
18300                                                      fmov.  */
18301                                                   return 137;
18302                                                 }
18303                                               else
18304                                                 {
18305                                                   /* 33222222222211111111110000000000
18306                                                      10987654321098765432109876543210
18307                                                      xxxxxxxxxx101111xxxxxxxx111101xx
18308                                                      fmov.  */
18309                                                   return 146;
18310                                                 }
18311                                             }
18312                                           else
18313                                             {
18314                                               if (((word >> 29) & 0x1) == 0)
18315                                                 {
18316                                                   /* 33222222222211111111110000000000
18317                                                      10987654321098765432109876543210
18318                                                      xxxxxxxxxx111111xxxxxxxx111100xx
18319                                                      fmov.  */
18320                                                   return 138;
18321                                                 }
18322                                               else
18323                                                 {
18324                                                   /* 33222222222211111111110000000000
18325                                                      10987654321098765432109876543210
18326                                                      xxxxxxxxxx111111xxxxxxxx111101xx
18327                                                      fcvtzu.  */
18328                                                   return 412;
18329                                                 }
18330                                             }
18331                                         }
18332                                     }
18333                                 }
18334                             }
18335                         }
18336                       else
18337                         {
18338                           if (((word >> 29) & 0x1) == 0)
18339                             {
18340                               if (((word >> 30) & 0x1) == 0)
18341                                 {
18342                                   if (((word >> 21) & 0x1) == 0)
18343                                     {
18344                                       /* 33222222222211111111110000000000
18345                                          10987654321098765432109876543210
18346                                          xxxxxxxxxxxxxxx1xxxxx0xx1111100x
18347                                          fmsub.  */
18348                                       return 842;
18349                                     }
18350                                   else
18351                                     {
18352                                       /* 33222222222211111111110000000000
18353                                          10987654321098765432109876543210
18354                                          xxxxxxxxxxxxxxx1xxxxx1xx1111100x
18355                                          fnmsub.  */
18356                                       return 846;
18357                                     }
18358                                 }
18359                               else
18360                                 {
18361                                   if (((word >> 10) & 0x1) == 0)
18362                                     {
18363                                       if (((word >> 12) & 0x1) == 0)
18364                                         {
18365                                           /* 33222222222211111111110000000000
18366                                              10987654321098765432109876543210
18367                                              xxxxxxxxxx0x0xx1xxxxxxxx1111101x
18368                                              sqdmulh.  */
18369                                           return 422;
18370                                         }
18371                                       else
18372                                         {
18373                                           if (((word >> 13) & 0x1) == 0)
18374                                             {
18375                                               if (((word >> 14) & 0x1) == 0)
18376                                                 {
18377                                                   if (((word >> 23) & 0x1) == 0)
18378                                                     {
18379                                                       /* 33222222222211111111110000000000
18380                                                          10987654321098765432109876543210
18381                                                          xxxxxxxxxx0x1001xxxxxxx01111101x
18382                                                          fmul.  */
18383                                                       return 429;
18384                                                     }
18385                                                   else
18386                                                     {
18387                                                       /* 33222222222211111111110000000000
18388                                                          10987654321098765432109876543210
18389                                                          xxxxxxxxxx0x1001xxxxxxx11111101x
18390                                                          fmul.  */
18391                                                       return 428;
18392                                                     }
18393                                                 }
18394                                               else
18395                                                 {
18396                                                   /* 33222222222211111111110000000000
18397                                                      10987654321098765432109876543210
18398                                                      xxxxxxxxxx0x1011xxxxxxxx1111101x
18399                                                      sqrdmulh.  */
18400                                                   return 423;
18401                                                 }
18402                                             }
18403                                           else
18404                                             {
18405                                               /* 33222222222211111111110000000000
18406                                                  10987654321098765432109876543210
18407                                                  xxxxxxxxxx0x11x1xxxxxxxx1111101x
18408                                                  sqdmull.  */
18409                                               return 421;
18410                                             }
18411                                         }
18412                                     }
18413                                   else
18414                                     {
18415                                       if (((word >> 11) & 0x1) == 0)
18416                                         {
18417                                           if (((word >> 12) & 0x1) == 0)
18418                                             {
18419                                               /* 33222222222211111111110000000000
18420                                                  10987654321098765432109876543210
18421                                                  xxxxxxxxxx100xx1xxxxxxxx1111101x
18422                                                  scvtf.  */
18423                                               return 592;
18424                                             }
18425                                           else
18426                                             {
18427                                               /* 33222222222211111111110000000000
18428                                                  10987654321098765432109876543210
18429                                                  xxxxxxxxxx101xx1xxxxxxxx1111101x
18430                                                  sqshrn.  */
18431                                               return 590;
18432                                             }
18433                                         }
18434                                       else
18435                                         {
18436                                           if (((word >> 13) & 0x1) == 0)
18437                                             {
18438                                               /* 33222222222211111111110000000000
18439                                                  10987654321098765432109876543210
18440                                                  xxxxxxxxxx11x0x1xxxxxxxx1111101x
18441                                                  sqrshrn.  */
18442                                               return 591;
18443                                             }
18444                                           else
18445                                             {
18446                                               /* 33222222222211111111110000000000
18447                                                  10987654321098765432109876543210
18448                                                  xxxxxxxxxx11x1x1xxxxxxxx1111101x
18449                                                  fcvtzs.  */
18450                                               return 594;
18451                                             }
18452                                         }
18453                                     }
18454                                 }
18455                             }
18456                           else
18457                             {
18458                               if (((word >> 10) & 0x1) == 0)
18459                                 {
18460                                   if (((word >> 13) & 0x1) == 0)
18461                                     {
18462                                       if (((word >> 14) & 0x1) == 0)
18463                                         {
18464                                           if (((word >> 23) & 0x1) == 0)
18465                                             {
18466                                               /* 33222222222211111111110000000000
18467                                                  10987654321098765432109876543210
18468                                                  xxxxxxxxxx0xx001xxxxxxx0111111xx
18469                                                  fmulx.  */
18470                                               return 431;
18471                                             }
18472                                           else
18473                                             {
18474                                               /* 33222222222211111111110000000000
18475                                                  10987654321098765432109876543210
18476                                                  xxxxxxxxxx0xx001xxxxxxx1111111xx
18477                                                  fmulx.  */
18478                                               return 430;
18479                                             }
18480                                         }
18481                                       else
18482                                         {
18483                                           /* 33222222222211111111110000000000
18484                                              10987654321098765432109876543210
18485                                              xxxxxxxxxx0xx011xxxxxxxx111111xx
18486                                              sqrdmlah.  */
18487                                           return 432;
18488                                         }
18489                                     }
18490                                   else
18491                                     {
18492                                       /* 33222222222211111111110000000000
18493                                          10987654321098765432109876543210
18494                                          xxxxxxxxxx0xx1x1xxxxxxxx111111xx
18495                                          sqrdmlsh.  */
18496                                       return 433;
18497                                     }
18498                                 }
18499                               else
18500                                 {
18501                                   if (((word >> 11) & 0x1) == 0)
18502                                     {
18503                                       if (((word >> 12) & 0x1) == 0)
18504                                         {
18505                                           if (((word >> 13) & 0x1) == 0)
18506                                             {
18507                                               /* 33222222222211111111110000000000
18508                                                  10987654321098765432109876543210
18509                                                  xxxxxxxxxx1000x1xxxxxxxx111111xx
18510                                                  sqshrun.  */
18511                                               return 604;
18512                                             }
18513                                           else
18514                                             {
18515                                               /* 33222222222211111111110000000000
18516                                                  10987654321098765432109876543210
18517                                                  xxxxxxxxxx1001x1xxxxxxxx111111xx
18518                                                  ucvtf.  */
18519                                               return 608;
18520                                             }
18521                                         }
18522                                       else
18523                                         {
18524                                           /* 33222222222211111111110000000000
18525                                              10987654321098765432109876543210
18526                                              xxxxxxxxxx101xx1xxxxxxxx111111xx
18527                                              uqshrn.  */
18528                                           return 606;
18529                                         }
18530                                     }
18531                                   else
18532                                     {
18533                                       if (((word >> 12) & 0x1) == 0)
18534                                         {
18535                                           /* 33222222222211111111110000000000
18536                                              10987654321098765432109876543210
18537                                              xxxxxxxxxx110xx1xxxxxxxx111111xx
18538                                              sqrshrun.  */
18539                                           return 605;
18540                                         }
18541                                       else
18542                                         {
18543                                           if (((word >> 13) & 0x1) == 0)
18544                                             {
18545                                               /* 33222222222211111111110000000000
18546                                                  10987654321098765432109876543210
18547                                                  xxxxxxxxxx1110x1xxxxxxxx111111xx
18548                                                  uqrshrn.  */
18549                                               return 607;
18550                                             }
18551                                           else
18552                                             {
18553                                               /* 33222222222211111111110000000000
18554                                                  10987654321098765432109876543210
18555                                                  xxxxxxxxxx1111x1xxxxxxxx111111xx
18556                                                  fcvtzu.  */
18557                                               return 610;
18558                                             }
18559                                         }
18560                                     }
18561                                 }
18562                             }
18563                         }
18564                     }
18565                 }
18566             }
18567         }
18568     }
18569 }
18570
18571 /* Lookup opcode WORD in the opcode table.  N.B. all alias
18572    opcodes are ignored here.  */
18573
18574 const aarch64_opcode *
18575 aarch64_opcode_lookup (uint32_t word)
18576 {
18577   return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);
18578 }
18579
18580 const aarch64_opcode *
18581 aarch64_find_next_opcode (const aarch64_opcode *opcode)
18582 {
18583   /* Use the index as the key to locate the next opcode.  */
18584   int key = opcode - aarch64_opcode_table;
18585   int value;
18586   switch (key)
18587     {
18588     case 941: value = 945; break;       /* stnp --> stp.  */
18589     case 945: return NULL;              /* stp --> NULL.  */
18590     case 939: value = 940; break;       /* stllrb --> stllrh.  */
18591     case 940: return NULL;              /* stllrh --> NULL.  */
18592     case 942: value = 946; break;       /* ldnp --> ldp.  */
18593     case 946: return NULL;              /* ldp --> NULL.  */
18594     case 1157: value = 1158; break;     /* msr --> hint.  */
18595     case 1158: value = 1172; break;     /* hint --> clrex.  */
18596     case 1172: value = 1173; break;     /* clrex --> dsb.  */
18597     case 1173: value = 1174; break;     /* dsb --> dmb.  */
18598     case 1174: value = 1175; break;     /* dmb --> isb.  */
18599     case 1175: value = 1176; break;     /* isb --> sys.  */
18600     case 1176: value = 1181; break;     /* sys --> msr.  */
18601     case 1181: return NULL;             /* msr --> NULL.  */
18602     case 1182: value = 1183; break;     /* sysl --> mrs.  */
18603     case 1183: return NULL;             /* mrs --> NULL.  */
18604     case 434: value = 435; break;       /* st4 --> st1.  */
18605     case 435: value = 436; break;       /* st1 --> st2.  */
18606     case 436: value = 437; break;       /* st2 --> st3.  */
18607     case 437: return NULL;              /* st3 --> NULL.  */
18608     case 442: value = 443; break;       /* st4 --> st1.  */
18609     case 443: value = 444; break;       /* st1 --> st2.  */
18610     case 444: value = 445; break;       /* st2 --> st3.  */
18611     case 445: return NULL;              /* st3 --> NULL.  */
18612     case 438: value = 439; break;       /* ld4 --> ld1.  */
18613     case 439: value = 440; break;       /* ld1 --> ld2.  */
18614     case 440: value = 441; break;       /* ld2 --> ld3.  */
18615     case 441: return NULL;              /* ld3 --> NULL.  */
18616     case 454: value = 456; break;       /* ld1 --> ld1r.  */
18617     case 456: return NULL;              /* ld1r --> NULL.  */
18618     case 458: value = 460; break;       /* ld2 --> ld2r.  */
18619     case 460: return NULL;              /* ld2r --> NULL.  */
18620     case 455: value = 457; break;       /* ld3 --> ld3r.  */
18621     case 457: return NULL;              /* ld3r --> NULL.  */
18622     case 459: value = 461; break;       /* ld4 --> ld4r.  */
18623     case 461: return NULL;              /* ld4r --> NULL.  */
18624     case 446: value = 447; break;       /* ld4 --> ld1.  */
18625     case 447: value = 448; break;       /* ld1 --> ld2.  */
18626     case 448: value = 449; break;       /* ld2 --> ld3.  */
18627     case 449: return NULL;              /* ld3 --> NULL.  */
18628     case 466: value = 468; break;       /* ld1 --> ld1r.  */
18629     case 468: return NULL;              /* ld1r --> NULL.  */
18630     case 467: value = 469; break;       /* ld3 --> ld3r.  */
18631     case 469: return NULL;              /* ld3r --> NULL.  */
18632     case 470: value = 472; break;       /* ld2 --> ld2r.  */
18633     case 472: return NULL;              /* ld2r --> NULL.  */
18634     case 471: value = 473; break;       /* ld4 --> ld4r.  */
18635     case 473: return NULL;              /* ld4r --> NULL.  */
18636     case 752: value = 753; break;       /* fcvtzs --> fcvtzs.  */
18637     case 753: return NULL;              /* fcvtzs --> NULL.  */
18638     case 748: value = 749; break;       /* scvtf --> scvtf.  */
18639     case 749: return NULL;              /* scvtf --> NULL.  */
18640     case 754: value = 755; break;       /* fcvtzu --> fcvtzu.  */
18641     case 755: return NULL;              /* fcvtzu --> NULL.  */
18642     case 750: value = 751; break;       /* ucvtf --> ucvtf.  */
18643     case 751: return NULL;              /* ucvtf --> NULL.  */
18644     case 756: value = 757; break;       /* fcvtns --> fcvtns.  */
18645     case 757: return NULL;              /* fcvtns --> NULL.  */
18646     case 776: value = 777; break;       /* fcvtms --> fcvtms.  */
18647     case 777: return NULL;              /* fcvtms --> NULL.  */
18648     case 772: value = 773; break;       /* fcvtps --> fcvtps.  */
18649     case 773: return NULL;              /* fcvtps --> NULL.  */
18650     case 780: value = 781; break;       /* fcvtzs --> fcvtzs.  */
18651     case 781: return NULL;              /* fcvtzs --> NULL.  */
18652     case 764: value = 765; break;       /* fcvtas --> fcvtas.  */
18653     case 765: return NULL;              /* fcvtas --> NULL.  */
18654     case 760: value = 761; break;       /* scvtf --> scvtf.  */
18655     case 761: return NULL;              /* scvtf --> NULL.  */
18656     case 768: value = 769; break;       /* fmov --> fmov.  */
18657     case 769: return NULL;              /* fmov --> NULL.  */
18658     case 758: value = 759; break;       /* fcvtnu --> fcvtnu.  */
18659     case 759: return NULL;              /* fcvtnu --> NULL.  */
18660     case 778: value = 779; break;       /* fcvtmu --> fcvtmu.  */
18661     case 779: return NULL;              /* fcvtmu --> NULL.  */
18662     case 774: value = 775; break;       /* fcvtpu --> fcvtpu.  */
18663     case 775: return NULL;              /* fcvtpu --> NULL.  */
18664     case 782: value = 783; break;       /* fcvtzu --> fcvtzu.  */
18665     case 783: return NULL;              /* fcvtzu --> NULL.  */
18666     case 766: value = 767; break;       /* fcvtau --> fcvtau.  */
18667     case 767: return NULL;              /* fcvtau --> NULL.  */
18668     case 762: value = 763; break;       /* ucvtf --> ucvtf.  */
18669     case 763: return NULL;              /* ucvtf --> NULL.  */
18670     case 770: value = 771; break;       /* fmov --> fmov.  */
18671     case 771: return NULL;              /* fmov --> NULL.  */
18672     case 799: value = 800; break;       /* fmov --> fmov.  */
18673     case 800: return NULL;              /* fmov --> NULL.  */
18674     case 808: value = 809; break;       /* frintn --> frintn.  */
18675     case 809: return NULL;              /* frintn --> NULL.  */
18676     case 803: value = 804; break;       /* fneg --> fneg.  */
18677     case 804: return NULL;              /* fneg --> NULL.  */
18678     case 812: value = 813; break;       /* frintm --> frintm.  */
18679     case 813: return NULL;              /* frintm --> NULL.  */
18680     case 801: value = 802; break;       /* fabs --> fabs.  */
18681     case 802: return NULL;              /* fabs --> NULL.  */
18682     case 810: value = 811; break;       /* frintp --> frintp.  */
18683     case 811: return NULL;              /* frintp --> NULL.  */
18684     case 805: value = 806; break;       /* fsqrt --> fsqrt.  */
18685     case 806: return NULL;              /* fsqrt --> NULL.  */
18686     case 814: value = 815; break;       /* frintz --> frintz.  */
18687     case 815: return NULL;              /* frintz --> NULL.  */
18688     case 816: value = 817; break;       /* frinta --> frinta.  */
18689     case 817: return NULL;              /* frinta --> NULL.  */
18690     case 818: value = 819; break;       /* frintx --> frintx.  */
18691     case 819: return NULL;              /* frintx --> NULL.  */
18692     case 820: value = 821; break;       /* frinti --> frinti.  */
18693     case 821: return NULL;              /* frinti --> NULL.  */
18694     case 791: value = 792; break;       /* fcmp --> fcmp.  */
18695     case 792: return NULL;              /* fcmp --> NULL.  */
18696     case 793: value = 794; break;       /* fcmpe --> fcmpe.  */
18697     case 794: return NULL;              /* fcmpe --> NULL.  */
18698     case 795: value = 796; break;       /* fcmp --> fcmp.  */
18699     case 796: return NULL;              /* fcmp --> NULL.  */
18700     case 797: value = 798; break;       /* fcmpe --> fcmpe.  */
18701     case 798: return NULL;              /* fcmpe --> NULL.  */
18702     case 848: value = 849; break;       /* fmov --> fmov.  */
18703     case 849: return NULL;              /* fmov --> NULL.  */
18704     case 822: value = 823; break;       /* fmul --> fmul.  */
18705     case 823: return NULL;              /* fmul --> NULL.  */
18706     case 838: value = 839; break;       /* fnmul --> fnmul.  */
18707     case 839: return NULL;              /* fnmul --> NULL.  */
18708     case 830: value = 831; break;       /* fmax --> fmax.  */
18709     case 831: return NULL;              /* fmax --> NULL.  */
18710     case 826: value = 827; break;       /* fadd --> fadd.  */
18711     case 827: return NULL;              /* fadd --> NULL.  */
18712     case 834: value = 835; break;       /* fmaxnm --> fmaxnm.  */
18713     case 835: return NULL;              /* fmaxnm --> NULL.  */
18714     case 824: value = 825; break;       /* fdiv --> fdiv.  */
18715     case 825: return NULL;              /* fdiv --> NULL.  */
18716     case 832: value = 833; break;       /* fmin --> fmin.  */
18717     case 833: return NULL;              /* fmin --> NULL.  */
18718     case 828: value = 829; break;       /* fsub --> fsub.  */
18719     case 829: return NULL;              /* fsub --> NULL.  */
18720     case 836: value = 837; break;       /* fminnm --> fminnm.  */
18721     case 837: return NULL;              /* fminnm --> NULL.  */
18722     case 787: value = 788; break;       /* fccmp --> fccmp.  */
18723     case 788: return NULL;              /* fccmp --> NULL.  */
18724     case 789: value = 790; break;       /* fccmpe --> fccmpe.  */
18725     case 790: return NULL;              /* fccmpe --> NULL.  */
18726     case 850: value = 851; break;       /* fcsel --> fcsel.  */
18727     case 851: return NULL;              /* fcsel --> NULL.  */
18728     case 131: value = 368; break;       /* movi --> sshr.  */
18729     case 368: value = 370; break;       /* sshr --> srshr.  */
18730     case 370: return NULL;              /* srshr --> NULL.  */
18731     case 139: value = 390; break;       /* mvni --> ushr.  */
18732     case 390: value = 392; break;       /* ushr --> urshr.  */
18733     case 392: value = 394; break;       /* urshr --> sri.  */
18734     case 394: value = 396; break;       /* sri --> sqshlu.  */
18735     case 396: return NULL;              /* sqshlu --> NULL.  */
18736     case 132: value = 369; break;       /* orr --> ssra.  */
18737     case 369: value = 371; break;       /* ssra --> srsra.  */
18738     case 371: value = 372; break;       /* srsra --> shl.  */
18739     case 372: value = 373; break;       /* shl --> sqshl.  */
18740     case 373: return NULL;              /* sqshl --> NULL.  */
18741     case 140: value = 391; break;       /* bic --> usra.  */
18742     case 391: value = 393; break;       /* usra --> ursra.  */
18743     case 393: value = 395; break;       /* ursra --> sli.  */
18744     case 395: value = 397; break;       /* sli --> uqshl.  */
18745     case 397: return NULL;              /* uqshl --> NULL.  */
18746     case 840: value = 841; break;       /* fmadd --> fmadd.  */
18747     case 841: return NULL;              /* fmadd --> NULL.  */
18748     case 844: value = 845; break;       /* fnmadd --> fnmadd.  */
18749     case 845: return NULL;              /* fnmadd --> NULL.  */
18750     case 133: value = 374; break;       /* movi --> shrn.  */
18751     case 374: value = 375; break;       /* shrn --> shrn2.  */
18752     case 375: value = 382; break;       /* shrn2 --> sshll.  */
18753     case 382: value = 384; break;       /* sshll --> sshll2.  */
18754     case 384: return NULL;              /* sshll2 --> NULL.  */
18755     case 141: value = 398; break;       /* mvni --> sqshrun.  */
18756     case 398: value = 399; break;       /* sqshrun --> sqshrun2.  */
18757     case 399: value = 406; break;       /* sqshrun2 --> ushll.  */
18758     case 406: value = 408; break;       /* ushll --> ushll2.  */
18759     case 408: return NULL;              /* ushll2 --> NULL.  */
18760     case 134: value = 378; break;       /* orr --> sqshrn.  */
18761     case 378: value = 379; break;       /* sqshrn --> sqshrn2.  */
18762     case 379: return NULL;              /* sqshrn2 --> NULL.  */
18763     case 142: value = 402; break;       /* bic --> uqshrn.  */
18764     case 402: value = 403; break;       /* uqshrn --> uqshrn2.  */
18765     case 403: return NULL;              /* uqshrn2 --> NULL.  */
18766     case 136: value = 386; break;       /* movi --> scvtf.  */
18767     case 386: value = 387; break;       /* scvtf --> scvtf.  */
18768     case 387: value = 1989; break;      /* scvtf --> sdot.  */
18769     case 1989: return NULL;             /* sdot --> NULL.  */
18770     case 144: value = 145; break;       /* movi --> movi.  */
18771     case 145: value = 410; break;       /* movi --> ucvtf.  */
18772     case 410: value = 411; break;       /* ucvtf --> ucvtf.  */
18773     case 411: value = 1988; break;      /* ucvtf --> udot.  */
18774     case 1988: return NULL;             /* udot --> NULL.  */
18775     case 138: value = 388; break;       /* fmov --> fcvtzs.  */
18776     case 388: value = 389; break;       /* fcvtzs --> fcvtzs.  */
18777     case 389: return NULL;              /* fcvtzs --> NULL.  */
18778     case 412: value = 413; break;       /* fcvtzu --> fcvtzu.  */
18779     case 413: return NULL;              /* fcvtzu --> NULL.  */
18780     case 842: value = 843; break;       /* fmsub --> fmsub.  */
18781     case 843: return NULL;              /* fmsub --> NULL.  */
18782     case 846: value = 847; break;       /* fnmsub --> fnmsub.  */
18783     case 847: return NULL;              /* fnmsub --> NULL.  */
18784     case 592: value = 593; break;       /* scvtf --> scvtf.  */
18785     case 593: return NULL;              /* scvtf --> NULL.  */
18786     case 594: value = 595; break;       /* fcvtzs --> fcvtzs.  */
18787     case 595: return NULL;              /* fcvtzs --> NULL.  */
18788     case 608: value = 609; break;       /* ucvtf --> ucvtf.  */
18789     case 609: return NULL;              /* ucvtf --> NULL.  */
18790     case 610: value = 611; break;       /* fcvtzu --> fcvtzu.  */
18791     case 611: return NULL;              /* fcvtzu --> NULL.  */
18792     default: return NULL;
18793     }
18794
18795   return aarch64_opcode_table + value;
18796 }
18797
18798 const aarch64_opcode *
18799 aarch64_find_alias_opcode (const aarch64_opcode *opcode)
18800 {
18801   /* Use the index as the key to locate the alias opcode.  */
18802   int key = opcode - aarch64_opcode_table;
18803   int value;
18804   switch (key)
18805     {
18806     case 2: value = 3; break;   /* sbc --> ngc.  */
18807     case 4: value = 5; break;   /* sbcs --> ngcs.  */
18808     case 7: value = 8; break;   /* adds --> cmn.  */
18809     case 10: value = 11; break; /* subs --> cmp.  */
18810     case 12: value = 13; break; /* add --> mov.  */
18811     case 14: value = 15; break; /* adds --> cmn.  */
18812     case 17: value = 18; break; /* subs --> cmp.  */
18813     case 20: value = 21; break; /* adds --> cmn.  */
18814     case 22: value = 23; break; /* sub --> neg.  */
18815     case 24: value = 26; break; /* subs --> negs.  */
18816     case 150: value = 151; break;       /* umov --> mov.  */
18817     case 152: value = 153; break;       /* ins --> mov.  */
18818     case 154: value = 155; break;       /* ins --> mov.  */
18819     case 236: value = 237; break;       /* not --> mvn.  */
18820     case 311: value = 312; break;       /* orr --> mov.  */
18821     case 382: value = 383; break;       /* sshll --> sxtl.  */
18822     case 384: value = 385; break;       /* sshll2 --> sxtl2.  */
18823     case 406: value = 407; break;       /* ushll --> uxtl.  */
18824     case 408: value = 409; break;       /* ushll2 --> uxtl2.  */
18825     case 529: value = 530; break;       /* dup --> mov.  */
18826     case 612: value = 617; break;       /* sbfm --> sxtw.  */
18827     case 619: value = 621; break;       /* bfm --> bfc.  */
18828     case 623: value = 627; break;       /* ubfm --> uxth.  */
18829     case 657: value = 659; break;       /* csinc --> cset.  */
18830     case 660: value = 662; break;       /* csinv --> csetm.  */
18831     case 663: value = 664; break;       /* csneg --> cneg.  */
18832     case 682: value = 682; break;       /* rev --> rev.  */
18833     case 707: value = 708; break;       /* lslv --> lsl.  */
18834     case 709: value = 710; break;       /* lsrv --> lsr.  */
18835     case 711: value = 712; break;       /* asrv --> asr.  */
18836     case 713: value = 714; break;       /* rorv --> ror.  */
18837     case 724: value = 725; break;       /* madd --> mul.  */
18838     case 726: value = 727; break;       /* msub --> mneg.  */
18839     case 728: value = 729; break;       /* smaddl --> smull.  */
18840     case 730: value = 731; break;       /* smsubl --> smnegl.  */
18841     case 733: value = 734; break;       /* umaddl --> umull.  */
18842     case 735: value = 736; break;       /* umsubl --> umnegl.  */
18843     case 746: value = 747; break;       /* extr --> ror.  */
18844     case 959: value = 960; break;       /* and --> bic.  */
18845     case 961: value = 962; break;       /* orr --> mov.  */
18846     case 964: value = 965; break;       /* ands --> tst.  */
18847     case 968: value = 970; break;       /* orr --> uxtw.  */
18848     case 971: value = 972; break;       /* orn --> mvn.  */
18849     case 975: value = 976; break;       /* ands --> tst.  */
18850     case 1006: value = 1102; break;     /* ldaddb --> staddb.  */
18851     case 1007: value = 1103; break;     /* ldaddh --> staddh.  */
18852     case 1008: value = 1104; break;     /* ldadd --> stadd.  */
18853     case 1010: value = 1105; break;     /* ldaddlb --> staddlb.  */
18854     case 1013: value = 1106; break;     /* ldaddlh --> staddlh.  */
18855     case 1016: value = 1107; break;     /* ldaddl --> staddl.  */
18856     case 1018: value = 1108; break;     /* ldclrb --> stclrb.  */
18857     case 1019: value = 1109; break;     /* ldclrh --> stclrh.  */
18858     case 1020: value = 1110; break;     /* ldclr --> stclr.  */
18859     case 1022: value = 1111; break;     /* ldclrlb --> stclrlb.  */
18860     case 1025: value = 1112; break;     /* ldclrlh --> stclrlh.  */
18861     case 1028: value = 1113; break;     /* ldclrl --> stclrl.  */
18862     case 1030: value = 1114; break;     /* ldeorb --> steorb.  */
18863     case 1031: value = 1115; break;     /* ldeorh --> steorh.  */
18864     case 1032: value = 1116; break;     /* ldeor --> steor.  */
18865     case 1034: value = 1117; break;     /* ldeorlb --> steorlb.  */
18866     case 1037: value = 1118; break;     /* ldeorlh --> steorlh.  */
18867     case 1040: value = 1119; break;     /* ldeorl --> steorl.  */
18868     case 1042: value = 1120; break;     /* ldsetb --> stsetb.  */
18869     case 1043: value = 1121; break;     /* ldseth --> stseth.  */
18870     case 1044: value = 1122; break;     /* ldset --> stset.  */
18871     case 1046: value = 1123; break;     /* ldsetlb --> stsetlb.  */
18872     case 1049: value = 1124; break;     /* ldsetlh --> stsetlh.  */
18873     case 1052: value = 1125; break;     /* ldsetl --> stsetl.  */
18874     case 1054: value = 1126; break;     /* ldsmaxb --> stsmaxb.  */
18875     case 1055: value = 1127; break;     /* ldsmaxh --> stsmaxh.  */
18876     case 1056: value = 1128; break;     /* ldsmax --> stsmax.  */
18877     case 1058: value = 1129; break;     /* ldsmaxlb --> stsmaxlb.  */
18878     case 1061: value = 1130; break;     /* ldsmaxlh --> stsmaxlh.  */
18879     case 1064: value = 1131; break;     /* ldsmaxl --> stsmaxl.  */
18880     case 1066: value = 1132; break;     /* ldsminb --> stsminb.  */
18881     case 1067: value = 1133; break;     /* ldsminh --> stsminh.  */
18882     case 1068: value = 1134; break;     /* ldsmin --> stsmin.  */
18883     case 1070: value = 1135; break;     /* ldsminlb --> stsminlb.  */
18884     case 1073: value = 1136; break;     /* ldsminlh --> stsminlh.  */
18885     case 1076: value = 1137; break;     /* ldsminl --> stsminl.  */
18886     case 1078: value = 1138; break;     /* ldumaxb --> stumaxb.  */
18887     case 1079: value = 1139; break;     /* ldumaxh --> stumaxh.  */
18888     case 1080: value = 1140; break;     /* ldumax --> stumax.  */
18889     case 1082: value = 1141; break;     /* ldumaxlb --> stumaxlb.  */
18890     case 1085: value = 1142; break;     /* ldumaxlh --> stumaxlh.  */
18891     case 1088: value = 1143; break;     /* ldumaxl --> stumaxl.  */
18892     case 1090: value = 1144; break;     /* lduminb --> stuminb.  */
18893     case 1091: value = 1145; break;     /* lduminh --> stuminh.  */
18894     case 1092: value = 1146; break;     /* ldumin --> stumin.  */
18895     case 1094: value = 1147; break;     /* lduminlb --> stuminlb.  */
18896     case 1097: value = 1148; break;     /* lduminlh --> stuminlh.  */
18897     case 1100: value = 1149; break;     /* lduminl --> stuminl.  */
18898     case 1150: value = 1151; break;     /* movn --> mov.  */
18899     case 1152: value = 1153; break;     /* movz --> mov.  */
18900     case 1158: value = 1191; break;     /* hint --> autibsp.  */
18901     case 1176: value = 1180; break;     /* sys --> tlbi.  */
18902     case 1239: value = 1973; break;     /* and --> bic.  */
18903     case 1241: value = 1222; break;     /* and --> mov.  */
18904     case 1242: value = 1226; break;     /* ands --> movs.  */
18905     case 1277: value = 1974; break;     /* cmpge --> cmple.  */
18906     case 1280: value = 1977; break;     /* cmpgt --> cmplt.  */
18907     case 1282: value = 1975; break;     /* cmphi --> cmplo.  */
18908     case 1285: value = 1976; break;     /* cmphs --> cmpls.  */
18909     case 1307: value = 1219; break;     /* cpy --> mov.  */
18910     case 1308: value = 1221; break;     /* cpy --> mov.  */
18911     case 1309: value = 1984; break;     /* cpy --> fmov.  */
18912     case 1321: value = 1214; break;     /* dup --> mov.  */
18913     case 1322: value = 1216; break;     /* dup --> mov.  */
18914     case 1323: value = 1983; break;     /* dup --> fmov.  */
18915     case 1324: value = 1217; break;     /* dupm --> mov.  */
18916     case 1326: value = 1978; break;     /* eor --> eon.  */
18917     case 1328: value = 1227; break;     /* eor --> not.  */
18918     case 1329: value = 1228; break;     /* eors --> nots.  */
18919     case 1334: value = 1979; break;     /* facge --> facle.  */
18920     case 1335: value = 1980; break;     /* facgt --> faclt.  */
18921     case 1348: value = 1981; break;     /* fcmge --> fcmle.  */
18922     case 1350: value = 1982; break;     /* fcmgt --> fcmlt.  */
18923     case 1356: value = 1211; break;     /* fcpy --> fmov.  */
18924     case 1379: value = 1210; break;     /* fdup --> fmov.  */
18925     case 1694: value = 1212; break;     /* orr --> mov.  */
18926     case 1695: value = 1985; break;     /* orr --> orn.  */
18927     case 1697: value = 1215; break;     /* orr --> mov.  */
18928     case 1698: value = 1225; break;     /* orrs --> movs.  */
18929     case 1760: value = 1220; break;     /* sel --> mov.  */
18930     case 1761: value = 1223; break;     /* sel --> mov.  */
18931     default: return NULL;
18932     }
18933
18934   return aarch64_opcode_table + value;
18935 }
18936
18937 const aarch64_opcode *
18938 aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)
18939 {
18940   /* Use the index as the key to locate the next opcode.  */
18941   int key = opcode - aarch64_opcode_table;
18942   int value;
18943   switch (key)
18944     {
18945     case 3: value = 2; break;   /* ngc --> sbc.  */
18946     case 5: value = 4; break;   /* ngcs --> sbcs.  */
18947     case 8: value = 7; break;   /* cmn --> adds.  */
18948     case 11: value = 10; break; /* cmp --> subs.  */
18949     case 13: value = 12; break; /* mov --> add.  */
18950     case 15: value = 14; break; /* cmn --> adds.  */
18951     case 18: value = 17; break; /* cmp --> subs.  */
18952     case 21: value = 20; break; /* cmn --> adds.  */
18953     case 23: value = 22; break; /* neg --> sub.  */
18954     case 26: value = 25; break; /* negs --> cmp.  */
18955     case 25: value = 24; break; /* cmp --> subs.  */
18956     case 151: value = 150; break;       /* mov --> umov.  */
18957     case 153: value = 152; break;       /* mov --> ins.  */
18958     case 155: value = 154; break;       /* mov --> ins.  */
18959     case 237: value = 236; break;       /* mvn --> not.  */
18960     case 312: value = 311; break;       /* mov --> orr.  */
18961     case 383: value = 382; break;       /* sxtl --> sshll.  */
18962     case 385: value = 384; break;       /* sxtl2 --> sshll2.  */
18963     case 407: value = 406; break;       /* uxtl --> ushll.  */
18964     case 409: value = 408; break;       /* uxtl2 --> ushll2.  */
18965     case 530: value = 529; break;       /* mov --> dup.  */
18966     case 617: value = 616; break;       /* sxtw --> sxth.  */
18967     case 616: value = 615; break;       /* sxth --> sxtb.  */
18968     case 615: value = 618; break;       /* sxtb --> asr.  */
18969     case 618: value = 614; break;       /* asr --> sbfx.  */
18970     case 614: value = 613; break;       /* sbfx --> sbfiz.  */
18971     case 613: value = 612; break;       /* sbfiz --> sbfm.  */
18972     case 621: value = 622; break;       /* bfc --> bfxil.  */
18973     case 622: value = 620; break;       /* bfxil --> bfi.  */
18974     case 620: value = 619; break;       /* bfi --> bfm.  */
18975     case 627: value = 626; break;       /* uxth --> uxtb.  */
18976     case 626: value = 629; break;       /* uxtb --> lsr.  */
18977     case 629: value = 628; break;       /* lsr --> lsl.  */
18978     case 628: value = 625; break;       /* lsl --> ubfx.  */
18979     case 625: value = 624; break;       /* ubfx --> ubfiz.  */
18980     case 624: value = 623; break;       /* ubfiz --> ubfm.  */
18981     case 659: value = 658; break;       /* cset --> cinc.  */
18982     case 658: value = 657; break;       /* cinc --> csinc.  */
18983     case 662: value = 661; break;       /* csetm --> cinv.  */
18984     case 661: value = 660; break;       /* cinv --> csinv.  */
18985     case 664: value = 663; break;       /* cneg --> csneg.  */
18986     case 682: value = 683; break;       /* rev --> rev64.  */
18987     case 708: value = 707; break;       /* lsl --> lslv.  */
18988     case 710: value = 709; break;       /* lsr --> lsrv.  */
18989     case 712: value = 711; break;       /* asr --> asrv.  */
18990     case 714: value = 713; break;       /* ror --> rorv.  */
18991     case 725: value = 724; break;       /* mul --> madd.  */
18992     case 727: value = 726; break;       /* mneg --> msub.  */
18993     case 729: value = 728; break;       /* smull --> smaddl.  */
18994     case 731: value = 730; break;       /* smnegl --> smsubl.  */
18995     case 734: value = 733; break;       /* umull --> umaddl.  */
18996     case 736: value = 735; break;       /* umnegl --> umsubl.  */
18997     case 747: value = 746; break;       /* ror --> extr.  */
18998     case 960: value = 959; break;       /* bic --> and.  */
18999     case 962: value = 961; break;       /* mov --> orr.  */
19000     case 965: value = 964; break;       /* tst --> ands.  */
19001     case 970: value = 969; break;       /* uxtw --> mov.  */
19002     case 969: value = 968; break;       /* mov --> orr.  */
19003     case 972: value = 971; break;       /* mvn --> orn.  */
19004     case 976: value = 975; break;       /* tst --> ands.  */
19005     case 1102: value = 1006; break;     /* staddb --> ldaddb.  */
19006     case 1103: value = 1007; break;     /* staddh --> ldaddh.  */
19007     case 1104: value = 1008; break;     /* stadd --> ldadd.  */
19008     case 1105: value = 1010; break;     /* staddlb --> ldaddlb.  */
19009     case 1106: value = 1013; break;     /* staddlh --> ldaddlh.  */
19010     case 1107: value = 1016; break;     /* staddl --> ldaddl.  */
19011     case 1108: value = 1018; break;     /* stclrb --> ldclrb.  */
19012     case 1109: value = 1019; break;     /* stclrh --> ldclrh.  */
19013     case 1110: value = 1020; break;     /* stclr --> ldclr.  */
19014     case 1111: value = 1022; break;     /* stclrlb --> ldclrlb.  */
19015     case 1112: value = 1025; break;     /* stclrlh --> ldclrlh.  */
19016     case 1113: value = 1028; break;     /* stclrl --> ldclrl.  */
19017     case 1114: value = 1030; break;     /* steorb --> ldeorb.  */
19018     case 1115: value = 1031; break;     /* steorh --> ldeorh.  */
19019     case 1116: value = 1032; break;     /* steor --> ldeor.  */
19020     case 1117: value = 1034; break;     /* steorlb --> ldeorlb.  */
19021     case 1118: value = 1037; break;     /* steorlh --> ldeorlh.  */
19022     case 1119: value = 1040; break;     /* steorl --> ldeorl.  */
19023     case 1120: value = 1042; break;     /* stsetb --> ldsetb.  */
19024     case 1121: value = 1043; break;     /* stseth --> ldseth.  */
19025     case 1122: value = 1044; break;     /* stset --> ldset.  */
19026     case 1123: value = 1046; break;     /* stsetlb --> ldsetlb.  */
19027     case 1124: value = 1049; break;     /* stsetlh --> ldsetlh.  */
19028     case 1125: value = 1052; break;     /* stsetl --> ldsetl.  */
19029     case 1126: value = 1054; break;     /* stsmaxb --> ldsmaxb.  */
19030     case 1127: value = 1055; break;     /* stsmaxh --> ldsmaxh.  */
19031     case 1128: value = 1056; break;     /* stsmax --> ldsmax.  */
19032     case 1129: value = 1058; break;     /* stsmaxlb --> ldsmaxlb.  */
19033     case 1130: value = 1061; break;     /* stsmaxlh --> ldsmaxlh.  */
19034     case 1131: value = 1064; break;     /* stsmaxl --> ldsmaxl.  */
19035     case 1132: value = 1066; break;     /* stsminb --> ldsminb.  */
19036     case 1133: value = 1067; break;     /* stsminh --> ldsminh.  */
19037     case 1134: value = 1068; break;     /* stsmin --> ldsmin.  */
19038     case 1135: value = 1070; break;     /* stsminlb --> ldsminlb.  */
19039     case 1136: value = 1073; break;     /* stsminlh --> ldsminlh.  */
19040     case 1137: value = 1076; break;     /* stsminl --> ldsminl.  */
19041     case 1138: value = 1078; break;     /* stumaxb --> ldumaxb.  */
19042     case 1139: value = 1079; break;     /* stumaxh --> ldumaxh.  */
19043     case 1140: value = 1080; break;     /* stumax --> ldumax.  */
19044     case 1141: value = 1082; break;     /* stumaxlb --> ldumaxlb.  */
19045     case 1142: value = 1085; break;     /* stumaxlh --> ldumaxlh.  */
19046     case 1143: value = 1088; break;     /* stumaxl --> ldumaxl.  */
19047     case 1144: value = 1090; break;     /* stuminb --> lduminb.  */
19048     case 1145: value = 1091; break;     /* stuminh --> lduminh.  */
19049     case 1146: value = 1092; break;     /* stumin --> ldumin.  */
19050     case 1147: value = 1094; break;     /* stuminlb --> lduminlb.  */
19051     case 1148: value = 1097; break;     /* stuminlh --> lduminlh.  */
19052     case 1149: value = 1100; break;     /* stuminl --> lduminl.  */
19053     case 1151: value = 1150; break;     /* mov --> movn.  */
19054     case 1153: value = 1152; break;     /* mov --> movz.  */
19055     case 1191: value = 1190; break;     /* autibsp --> autibz.  */
19056     case 1190: value = 1189; break;     /* autibz --> autiasp.  */
19057     case 1189: value = 1188; break;     /* autiasp --> autiaz.  */
19058     case 1188: value = 1187; break;     /* autiaz --> pacibsp.  */
19059     case 1187: value = 1186; break;     /* pacibsp --> pacibz.  */
19060     case 1186: value = 1185; break;     /* pacibz --> paciasp.  */
19061     case 1185: value = 1184; break;     /* paciasp --> paciaz.  */
19062     case 1184: value = 1171; break;     /* paciaz --> psb.  */
19063     case 1171: value = 1170; break;     /* psb --> esb.  */
19064     case 1170: value = 1169; break;     /* esb --> autib1716.  */
19065     case 1169: value = 1168; break;     /* autib1716 --> autia1716.  */
19066     case 1168: value = 1167; break;     /* autia1716 --> pacib1716.  */
19067     case 1167: value = 1166; break;     /* pacib1716 --> pacia1716.  */
19068     case 1166: value = 1165; break;     /* pacia1716 --> xpaclri.  */
19069     case 1165: value = 1164; break;     /* xpaclri --> sevl.  */
19070     case 1164: value = 1163; break;     /* sevl --> sev.  */
19071     case 1163: value = 1162; break;     /* sev --> wfi.  */
19072     case 1162: value = 1161; break;     /* wfi --> wfe.  */
19073     case 1161: value = 1160; break;     /* wfe --> yield.  */
19074     case 1160: value = 1159; break;     /* yield --> nop.  */
19075     case 1159: value = 1158; break;     /* nop --> hint.  */
19076     case 1180: value = 1179; break;     /* tlbi --> ic.  */
19077     case 1179: value = 1178; break;     /* ic --> dc.  */
19078     case 1178: value = 1177; break;     /* dc --> at.  */
19079     case 1177: value = 1176; break;     /* at --> sys.  */
19080     case 1973: value = 1239; break;     /* bic --> and.  */
19081     case 1222: value = 1241; break;     /* mov --> and.  */
19082     case 1226: value = 1242; break;     /* movs --> ands.  */
19083     case 1974: value = 1277; break;     /* cmple --> cmpge.  */
19084     case 1977: value = 1280; break;     /* cmplt --> cmpgt.  */
19085     case 1975: value = 1282; break;     /* cmplo --> cmphi.  */
19086     case 1976: value = 1285; break;     /* cmpls --> cmphs.  */
19087     case 1219: value = 1307; break;     /* mov --> cpy.  */
19088     case 1221: value = 1308; break;     /* mov --> cpy.  */
19089     case 1984: value = 1224; break;     /* fmov --> mov.  */
19090     case 1224: value = 1309; break;     /* mov --> cpy.  */
19091     case 1214: value = 1321; break;     /* mov --> dup.  */
19092     case 1216: value = 1213; break;     /* mov --> mov.  */
19093     case 1213: value = 1322; break;     /* mov --> dup.  */
19094     case 1983: value = 1218; break;     /* fmov --> mov.  */
19095     case 1218: value = 1323; break;     /* mov --> dup.  */
19096     case 1217: value = 1324; break;     /* mov --> dupm.  */
19097     case 1978: value = 1326; break;     /* eon --> eor.  */
19098     case 1227: value = 1328; break;     /* not --> eor.  */
19099     case 1228: value = 1329; break;     /* nots --> eors.  */
19100     case 1979: value = 1334; break;     /* facle --> facge.  */
19101     case 1980: value = 1335; break;     /* faclt --> facgt.  */
19102     case 1981: value = 1348; break;     /* fcmle --> fcmge.  */
19103     case 1982: value = 1350; break;     /* fcmlt --> fcmgt.  */
19104     case 1211: value = 1356; break;     /* fmov --> fcpy.  */
19105     case 1210: value = 1379; break;     /* fmov --> fdup.  */
19106     case 1212: value = 1694; break;     /* mov --> orr.  */
19107     case 1985: value = 1695; break;     /* orn --> orr.  */
19108     case 1215: value = 1697; break;     /* mov --> orr.  */
19109     case 1225: value = 1698; break;     /* movs --> orrs.  */
19110     case 1220: value = 1760; break;     /* mov --> sel.  */
19111     case 1223: value = 1761; break;     /* mov --> sel.  */
19112     default: return NULL;
19113     }
19114
19115   return aarch64_opcode_table + value;
19116 }
19117
19118 int
19119 aarch64_extract_operand (const aarch64_operand *self,
19120                            aarch64_opnd_info *info,
19121                            aarch64_insn code, const aarch64_inst *inst)
19122 {
19123   /* Use the index as the key.  */
19124   int key = self - aarch64_operands;
19125   switch (key)
19126     {
19127     case 1:
19128     case 2:
19129     case 3:
19130     case 4:
19131     case 5:
19132     case 6:
19133     case 7:
19134     case 9:
19135     case 10:
19136     case 11:
19137     case 15:
19138     case 16:
19139     case 17:
19140     case 18:
19141     case 20:
19142     case 21:
19143     case 22:
19144     case 23:
19145     case 24:
19146     case 25:
19147     case 26:
19148     case 27:
19149     case 28:
19150     case 147:
19151     case 148:
19152     case 149:
19153     case 150:
19154     case 151:
19155     case 152:
19156     case 153:
19157     case 154:
19158     case 155:
19159     case 156:
19160     case 169:
19161     case 170:
19162     case 171:
19163     case 172:
19164     case 173:
19165     case 174:
19166     case 175:
19167     case 176:
19168     case 177:
19169     case 181:
19170     case 184:
19171       return aarch64_ext_regno (self, info, code, inst);
19172     case 8:
19173       return aarch64_ext_regrt_sysins (self, info, code, inst);
19174     case 12:
19175       return aarch64_ext_regno_pair (self, info, code, inst);
19176     case 13:
19177       return aarch64_ext_reg_extended (self, info, code, inst);
19178     case 14:
19179       return aarch64_ext_reg_shifted (self, info, code, inst);
19180     case 19:
19181       return aarch64_ext_ft (self, info, code, inst);
19182     case 29:
19183     case 30:
19184     case 31:
19185       return aarch64_ext_reglane (self, info, code, inst);
19186     case 32:
19187       return aarch64_ext_reglist (self, info, code, inst);
19188     case 33:
19189       return aarch64_ext_ldst_reglist (self, info, code, inst);
19190     case 34:
19191       return aarch64_ext_ldst_reglist_r (self, info, code, inst);
19192     case 35:
19193       return aarch64_ext_ldst_elemlist (self, info, code, inst);
19194     case 36:
19195     case 37:
19196     case 38:
19197     case 48:
19198     case 49:
19199     case 50:
19200     case 51:
19201     case 52:
19202     case 53:
19203     case 54:
19204     case 55:
19205     case 56:
19206     case 57:
19207     case 58:
19208     case 59:
19209     case 60:
19210     case 71:
19211     case 72:
19212     case 73:
19213     case 74:
19214     case 75:
19215     case 144:
19216     case 146:
19217     case 161:
19218     case 162:
19219     case 163:
19220     case 164:
19221     case 165:
19222     case 166:
19223     case 167:
19224     case 168:
19225       return aarch64_ext_imm (self, info, code, inst);
19226     case 39:
19227     case 40:
19228       return aarch64_ext_advsimd_imm_shift (self, info, code, inst);
19229     case 41:
19230     case 42:
19231     case 43:
19232       return aarch64_ext_advsimd_imm_modified (self, info, code, inst);
19233     case 44:
19234       return aarch64_ext_shll_imm (self, info, code, inst);
19235     case 47:
19236     case 135:
19237       return aarch64_ext_fpimm (self, info, code, inst);
19238     case 61:
19239     case 142:
19240       return aarch64_ext_limm (self, info, code, inst);
19241     case 62:
19242       return aarch64_ext_aimm (self, info, code, inst);
19243     case 63:
19244       return aarch64_ext_imm_half (self, info, code, inst);
19245     case 64:
19246       return aarch64_ext_fbits (self, info, code, inst);
19247     case 66:
19248     case 67:
19249     case 140:
19250       return aarch64_ext_imm_rotate2 (self, info, code, inst);
19251     case 68:
19252     case 139:
19253       return aarch64_ext_imm_rotate1 (self, info, code, inst);
19254     case 69:
19255     case 70:
19256       return aarch64_ext_cond (self, info, code, inst);
19257     case 76:
19258     case 83:
19259       return aarch64_ext_addr_simple (self, info, code, inst);
19260     case 77:
19261       return aarch64_ext_addr_regoff (self, info, code, inst);
19262     case 78:
19263     case 79:
19264     case 80:
19265       return aarch64_ext_addr_simm (self, info, code, inst);
19266     case 81:
19267       return aarch64_ext_addr_simm10 (self, info, code, inst);
19268     case 82:
19269       return aarch64_ext_addr_uimm12 (self, info, code, inst);
19270     case 84:
19271       return aarch64_ext_simd_addr_post (self, info, code, inst);
19272     case 85:
19273       return aarch64_ext_sysreg (self, info, code, inst);
19274     case 86:
19275       return aarch64_ext_pstatefield (self, info, code, inst);
19276     case 87:
19277     case 88:
19278     case 89:
19279     case 90:
19280       return aarch64_ext_sysins_op (self, info, code, inst);
19281     case 91:
19282     case 92:
19283       return aarch64_ext_barrier (self, info, code, inst);
19284     case 93:
19285       return aarch64_ext_prfop (self, info, code, inst);
19286     case 94:
19287       return aarch64_ext_hint (self, info, code, inst);
19288     case 95:
19289       return aarch64_ext_sve_addr_ri_s4 (self, info, code, inst);
19290     case 96:
19291     case 97:
19292     case 98:
19293     case 99:
19294       return aarch64_ext_sve_addr_ri_s4xvl (self, info, code, inst);
19295     case 100:
19296       return aarch64_ext_sve_addr_ri_s6xvl (self, info, code, inst);
19297     case 101:
19298       return aarch64_ext_sve_addr_ri_s9xvl (self, info, code, inst);
19299     case 102:
19300     case 103:
19301     case 104:
19302     case 105:
19303       return aarch64_ext_sve_addr_ri_u6 (self, info, code, inst);
19304     case 106:
19305     case 107:
19306     case 108:
19307     case 109:
19308     case 110:
19309     case 111:
19310     case 112:
19311     case 113:
19312     case 114:
19313     case 115:
19314     case 116:
19315     case 117:
19316       return aarch64_ext_sve_addr_rr_lsl (self, info, code, inst);
19317     case 118:
19318     case 119:
19319     case 120:
19320     case 121:
19321     case 122:
19322     case 123:
19323     case 124:
19324     case 125:
19325       return aarch64_ext_sve_addr_rz_xtw (self, info, code, inst);
19326     case 126:
19327     case 127:
19328     case 128:
19329     case 129:
19330       return aarch64_ext_sve_addr_zi_u5 (self, info, code, inst);
19331     case 130:
19332       return aarch64_ext_sve_addr_zz_lsl (self, info, code, inst);
19333     case 131:
19334       return aarch64_ext_sve_addr_zz_sxtw (self, info, code, inst);
19335     case 132:
19336       return aarch64_ext_sve_addr_zz_uxtw (self, info, code, inst);
19337     case 133:
19338       return aarch64_ext_sve_aimm (self, info, code, inst);
19339     case 134:
19340       return aarch64_ext_sve_asimm (self, info, code, inst);
19341     case 136:
19342       return aarch64_ext_sve_float_half_one (self, info, code, inst);
19343     case 137:
19344       return aarch64_ext_sve_float_half_two (self, info, code, inst);
19345     case 138:
19346       return aarch64_ext_sve_float_zero_one (self, info, code, inst);
19347     case 141:
19348       return aarch64_ext_inv_limm (self, info, code, inst);
19349     case 143:
19350       return aarch64_ext_sve_limm_mov (self, info, code, inst);
19351     case 145:
19352       return aarch64_ext_sve_scale (self, info, code, inst);
19353     case 157:
19354     case 158:
19355       return aarch64_ext_sve_shlimm (self, info, code, inst);
19356     case 159:
19357     case 160:
19358       return aarch64_ext_sve_shrimm (self, info, code, inst);
19359     case 178:
19360     case 179:
19361     case 180:
19362       return aarch64_ext_sve_quad_index (self, info, code, inst);
19363     case 182:
19364       return aarch64_ext_sve_index (self, info, code, inst);
19365     case 183:
19366     case 185:
19367       return aarch64_ext_sve_reglist (self, info, code, inst);
19368     default: assert (0); abort ();
19369     }
19370 }