opcodes/aarch64-dis-2.c

   1 /* This file is automatically generated by aarch64-gen.  Do not edit!  */
   2 /* Copyright (C) 2012-2023 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 >> 28) & 0x1) == 0)
  38                     {
  39                       if (((word >> 21) & 0x1) == 0)
  40                         {
  41                           if (((word >> 29) & 0x1) == 0)
  42                             {
  43                               if (((word >> 30) & 0x1) == 0)
  44                                 {
  45                                   if (((word >> 22) & 0x1) == 0)
  46                                     {
  47                                       if (((word >> 23) & 0x1) == 0)
  48                                         {
  49                                           /* 33222222222211111111110000000000
  50                                              10987654321098765432109876543210
  51                                              x0000000000xxxxxxxxxxxxxxxxxxxxx
  52                                              udf.  */
  53                                           return 754;
  54                                         }
  55                                       else
  56                                         {
  57                                           if (((word >> 4) & 0x1) == 0)
  58                                             {
  59                                               /* 33222222222211111111110000000000
  60                                                  10987654321098765432109876543210
  61                                                  x0000000100xxxxxxxxxxxxxxxx0xxxx
  62                                                  fmopa.  */
  63                                               return 2361;
  64                                             }
  65                                           else
  66                                             {
  67                                               /* 33222222222211111111110000000000
  68                                                  10987654321098765432109876543210
  69                                                  x0000000100xxxxxxxxxxxxxxxx1xxxx
  70                                                  fmops.  */
  71                                               return 2364;
  72                                             }
  73                                         }
  74                                     }
  75                                   else
  76                                     {
  77                                       if (((word >> 4) & 0x1) == 0)
  78                                         {
  79                                           /* 33222222222211111111110000000000
  80                                              10987654321098765432109876543210
  81                                              x0000000x10xxxxxxxxxxxxxxxx0xxxx
  82                                              fmopa.  */
  83                                           return 2362;
  84                                         }
  85                                       else
  86                                         {
  87                                           /* 33222222222211111111110000000000
  88                                              10987654321098765432109876543210
  89                                              x0000000x10xxxxxxxxxxxxxxxx1xxxx
  90                                              fmops.  */
  91                                           return 2365;
  92                                         }
  93                                     }
  94                                 }
  95                               else
  96                                 {
  97                                   if (((word >> 17) & 0x1) == 0)
  98                                     {
  99                                       if (((word >> 19) & 0x1) == 0)
 100                                         {
 101                                           if (((word >> 20) & 0x1) == 0)
 102                                             {
 103                                               /* 33222222222211111111110000000000
 104                                                  10987654321098765432109876543210
 105                                                  x1000000xx000x0xxxxxxxxxxxxxxxxx
 106                                                  mov.  */
 107                                               return 2385;
 108                                             }
 109                                           else
 110                                             {
 111                                               if (((word >> 16) & 0x1) == 0)
 112                                                 {
 113                                                   if (((word >> 22) & 0x1) == 0)
 114                                                     {
 115                                                       /* 33222222222211111111110000000000
 116                                                          10987654321098765432109876543210
 117                                                          x1000000x0010x00xxxxxxxxxxxxxxxx
 118                                                          addha.  */
 119                                                       return 2353;
 120                                                     }
 121                                                   else
 122                                                     {
 123                                                       /* 33222222222211111111110000000000
 124                                                          10987654321098765432109876543210
 125                                                          x1000000x1010x00xxxxxxxxxxxxxxxx
 126                                                          addha.  */
 127                                                       return 2354;
 128                                                     }
 129                                                 }
 130                                               else
 131                                                 {
 132                                                   if (((word >> 22) & 0x1) == 0)
 133                                                     {
 134                                                       /* 33222222222211111111110000000000
 135                                                          10987654321098765432109876543210
 136                                                          x1000000x0010x01xxxxxxxxxxxxxxxx
 137                                                          addva.  */
 138                                                       return 2357;
 139                                                     }
 140                                                   else
 141                                                     {
 142                                                       /* 33222222222211111111110000000000
 143                                                          10987654321098765432109876543210
 144                                                          x1000000x1010x01xxxxxxxxxxxxxxxx
 145                                                          addva.  */
 146                                                       return 2358;
 147                                                     }
 148                                                 }
 149                                             }
 150                                         }
 151                                       else
 152                                         {
 153                                           /* 33222222222211111111110000000000
 154                                              10987654321098765432109876543210
 155                                              x1000000xx0x1x0xxxxxxxxxxxxxxxxx
 156                                              zero.  */
 157                                           return 2388;
 158                                         }
 159                                     }
 160                                   else
 161                                     {
 162                                       /* 33222222222211111111110000000000
 163                                          10987654321098765432109876543210
 164                                          x1000000xx0xxx1xxxxxxxxxxxxxxxxx
 165                                          mov.  */
 166                                       return 2384;
 167                                     }
 168                                 }
 169                             }
 170                           else
 171                             {
 172                               if (((word >> 4) & 0x1) == 0)
 173                                 {
 174                                   if (((word >> 22) & 0x1) == 0)
 175                                     {
 176                                       if (((word >> 23) & 0x1) == 0)
 177                                         {
 178                                           /* 33222222222211111111110000000000
 179                                              10987654321098765432109876543210
 180                                              xx100000000xxxxxxxxxxxxxxxx0xxxx
 181                                              ld1b.  */
 182                                           return 2389;
 183                                         }
 184                                       else
 185                                         {
 186                                           if (((word >> 30) & 0x1) == 0)
 187                                             {
 188                                               /* 33222222222211111111110000000000
 189                                                  10987654321098765432109876543210
 190                                                  x0100000100xxxxxxxxxxxxxxxx0xxxx
 191                                                  smopa.  */
 192                                               return 2368;
 193                                             }
 194                                           else
 195                                             {
 196                                               /* 33222222222211111111110000000000
 197                                                  10987654321098765432109876543210
 198                                                  x1100000100xxxxxxxxxxxxxxxx0xxxx
 199                                                  ld1w.  */
 200                                               return 2391;
 201                                             }
 202                                         }
 203                                     }
 204                                   else
 205                                     {
 206                                       if (((word >> 23) & 0x1) == 0)
 207                                         {
 208                                           /* 33222222222211111111110000000000
 209                                              10987654321098765432109876543210
 210                                              xx100000010xxxxxxxxxxxxxxxx0xxxx
 211                                              ld1h.  */
 212                                           return 2390;
 213                                         }
 214                                       else
 215                                         {
 216                                           if (((word >> 30) & 0x1) == 0)
 217                                             {
 218                                               /* 33222222222211111111110000000000
 219                                                  10987654321098765432109876543210
 220                                                  x0100000110xxxxxxxxxxxxxxxx0xxxx
 221                                                  smopa.  */
 222                                               return 2369;
 223                                             }
 224                                           else
 225                                             {
 226                                               /* 33222222222211111111110000000000
 227                                                  10987654321098765432109876543210
 228                                                  x1100000110xxxxxxxxxxxxxxxx0xxxx
 229                                                  ld1d.  */
 230                                               return 2392;
 231                                             }
 232                                         }
 233                                     }
 234                                 }
 235                               else
 236                                 {
 237                                   if (((word >> 22) & 0x1) == 0)
 238                                     {
 239                                       /* 33222222222211111111110000000000
 240                                          10987654321098765432109876543210
 241                                          xx100000x00xxxxxxxxxxxxxxxx1xxxx
 242                                          smops.  */
 243                                       return 2370;
 244                                     }
 245                                   else
 246                                     {
 247                                       /* 33222222222211111111110000000000
 248                                          10987654321098765432109876543210
 249                                          xx100000x10xxxxxxxxxxxxxxxx1xxxx
 250                                          smops.  */
 251                                       return 2371;
 252                                     }
 253                                 }
 254                             }
 255                         }
 256                       else
 257                         {
 258                           if (((word >> 4) & 0x1) == 0)
 259                             {
 260                               if (((word >> 22) & 0x1) == 0)
 261                                 {
 262                                   if (((word >> 23) & 0x1) == 0)
 263                                     {
 264                                       /* 33222222222211111111110000000000
 265                                          10987654321098765432109876543210
 266                                          xxx00000001xxxxxxxxxxxxxxxx0xxxx
 267                                          st1b.  */
 268                                       return 2399;
 269                                     }
 270                                   else
 271                                     {
 272                                       if (((word >> 30) & 0x1) == 0)
 273                                         {
 274                                           /* 33222222222211111111110000000000
 275                                              10987654321098765432109876543210
 276                                              x0x00000101xxxxxxxxxxxxxxxx0xxxx
 277                                              sumopa.  */
 278                                           return 2372;
 279                                         }
 280                                       else
 281                                         {
 282                                           /* 33222222222211111111110000000000
 283                                              10987654321098765432109876543210
 284                                              x1x00000101xxxxxxxxxxxxxxxx0xxxx
 285                                              st1w.  */
 286                                           return 2401;
 287                                         }
 288                                     }
 289                                 }
 290                               else
 291                                 {
 292                                   if (((word >> 23) & 0x1) == 0)
 293                                     {
 294                                       /* 33222222222211111111110000000000
 295                                          10987654321098765432109876543210
 296                                          xxx00000011xxxxxxxxxxxxxxxx0xxxx
 297                                          st1h.  */
 298                                       return 2400;
 299                                     }
 300                                   else
 301                                     {
 302                                       if (((word >> 30) & 0x1) == 0)
 303                                         {
 304                                           /* 33222222222211111111110000000000
 305                                              10987654321098765432109876543210
 306                                              x0x00000111xxxxxxxxxxxxxxxx0xxxx
 307                                              sumopa.  */
 308                                           return 2373;
 309                                         }
 310                                       else
 311                                         {
 312                                           /* 33222222222211111111110000000000
 313                                              10987654321098765432109876543210
 314                                              x1x00000111xxxxxxxxxxxxxxxx0xxxx
 315                                              st1d.  */
 316                                           return 2402;
 317                                         }
 318                                     }
 319                                 }
 320                             }
 321                           else
 322                             {
 323                               if (((word >> 22) & 0x1) == 0)
 324                                 {
 325                                   /* 33222222222211111111110000000000
 326                                      10987654321098765432109876543210
 327                                      xxx00000x01xxxxxxxxxxxxxxxx1xxxx
 328                                      sumops.  */
 329                                   return 2374;
 330                                 }
 331                               else
 332                                 {
 333                                   /* 33222222222211111111110000000000
 334                                      10987654321098765432109876543210
 335                                      xxx00000x11xxxxxxxxxxxxxxxx1xxxx
 336                                      sumops.  */
 337                                   return 2375;
 338                                 }
 339                             }
 340                         }
 341                     }
 342                   else
 343                     {
 344                       if (((word >> 31) & 0x1) == 0)
 345                         {
 346                           /* 33222222222211111111110000000000
 347                              10987654321098765432109876543210
 348                              0xx10000xxxxxxxxxxxxxxxxxxxxxxxx
 349                              adr.  */
 350                           return 1191;
 351                         }
 352                       else
 353                         {
 354                           /* 33222222222211111111110000000000
 355                              10987654321098765432109876543210
 356                              1xx10000xxxxxxxxxxxxxxxxxxxxxxxx
 357                              adrp.  */
 358                           return 1192;
 359                         }
 360                     }
 361                 }
 362               else
 363                 {
 364                   if (((word >> 28) & 0x1) == 0)
 365                     {
 366                       if (((word >> 4) & 0x1) == 0)
 367                         {
 368                           if (((word >> 21) & 0x1) == 0)
 369                             {
 370                               if (((word >> 22) & 0x1) == 0)
 371                                 {
 372                                   if (((word >> 23) & 0x1) == 0)
 373                                     {
 374                                       /* 33222222222211111111110000000000
 375                                          10987654321098765432109876543210
 376                                          xxx00001000xxxxxxxxxxxxxxxx0xxxx
 377                                          ldr.  */
 378                                       return 2409;
 379                                     }
 380                                   else
 381                                     {
 382                                       if (((word >> 29) & 0x1) == 0)
 383                                         {
 384                                           /* 33222222222211111111110000000000
 385                                              10987654321098765432109876543210
 386                                              xx000001100xxxxxxxxxxxxxxxx0xxxx
 387                                              bfmopa.  */
 388                                           return 2359;
 389                                         }
 390                                       else
 391                                         {
 392                                           /* 33222222222211111111110000000000
 393                                              10987654321098765432109876543210
 394                                              xx100001100xxxxxxxxxxxxxxxx0xxxx
 395                                              usmopa.  */
 396                                           return 2380;
 397                                         }
 398                                     }
 399                                 }
 400                               else
 401                                 {
 402                                   if (((word >> 30) & 0x1) == 0)
 403                                     {
 404                                       /* 33222222222211111111110000000000
 405                                          10987654321098765432109876543210
 406                                          x0x00001x10xxxxxxxxxxxxxxxx0xxxx
 407                                          usmopa.  */
 408                                       return 2381;
 409                                     }
 410                                   else
 411                                     {
 412                                       /* 33222222222211111111110000000000
 413                                          10987654321098765432109876543210
 414                                          x1x00001x10xxxxxxxxxxxxxxxx0xxxx
 415                                          ld1q.  */
 416                                       return 2393;
 417                                     }
 418                                 }
 419                             }
 420                           else
 421                             {
 422                               if (((word >> 22) & 0x1) == 0)
 423                                 {
 424                                   if (((word >> 23) & 0x1) == 0)
 425                                     {
 426                                       /* 33222222222211111111110000000000
 427                                          10987654321098765432109876543210
 428                                          xxx00001001xxxxxxxxxxxxxxxx0xxxx
 429                                          str.  */
 430                                       return 2410;
 431                                     }
 432                                   else
 433                                     {
 434                                       if (((word >> 29) & 0x1) == 0)
 435                                         {
 436                                           /* 33222222222211111111110000000000
 437                                              10987654321098765432109876543210
 438                                              xx000001101xxxxxxxxxxxxxxxx0xxxx
 439                                              fmopa.  */
 440                                           return 2363;
 441                                         }
 442                                       else
 443                                         {
 444                                           /* 33222222222211111111110000000000
 445                                              10987654321098765432109876543210
 446                                              xx100001101xxxxxxxxxxxxxxxx0xxxx
 447                                              umopa.  */
 448                                           return 2376;
 449                                         }
 450                                     }
 451                                 }
 452                               else
 453                                 {
 454                                   if (((word >> 30) & 0x1) == 0)
 455                                     {
 456                                       /* 33222222222211111111110000000000
 457                                          10987654321098765432109876543210
 458                                          x0x00001x11xxxxxxxxxxxxxxxx0xxxx
 459                                          umopa.  */
 460                                       return 2377;
 461                                     }
 462                                   else
 463                                     {
 464                                       /* 33222222222211111111110000000000
 465                                          10987654321098765432109876543210
 466                                          x1x00001x11xxxxxxxxxxxxxxxx0xxxx
 467                                          st1q.  */
 468                                       return 2403;
 469                                     }
 470                                 }
 471                             }
 472                         }
 473                       else
 474                         {
 475                           if (((word >> 21) & 0x1) == 0)
 476                             {
 477                               if (((word >> 22) & 0x1) == 0)
 478                                 {
 479                                   if (((word >> 29) & 0x1) == 0)
 480                                     {
 481                                       /* 33222222222211111111110000000000
 482                                          10987654321098765432109876543210
 483                                          xx000001x00xxxxxxxxxxxxxxxx1xxxx
 484                                          bfmops.  */
 485                                       return 2360;
 486                                     }
 487                                   else
 488                                     {
 489                                       /* 33222222222211111111110000000000
 490                                          10987654321098765432109876543210
 491                                          xx100001x00xxxxxxxxxxxxxxxx1xxxx
 492                                          usmops.  */
 493                                       return 2382;
 494                                     }
 495                                 }
 496                               else
 497                                 {
 498                                   /* 33222222222211111111110000000000
 499                                      10987654321098765432109876543210
 500                                      xxx00001x10xxxxxxxxxxxxxxxx1xxxx
 501                                      usmops.  */
 502                                   return 2383;
 503                                 }
 504                             }
 505                           else
 506                             {
 507                               if (((word >> 22) & 0x1) == 0)
 508                                 {
 509                                   if (((word >> 29) & 0x1) == 0)
 510                                     {
 511                                       /* 33222222222211111111110000000000
 512                                          10987654321098765432109876543210
 513                                          xx000001x01xxxxxxxxxxxxxxxx1xxxx
 514                                          fmops.  */
 515                                       return 2366;
 516                                     }
 517                                   else
 518                                     {
 519                                       /* 33222222222211111111110000000000
 520                                          10987654321098765432109876543210
 521                                          xx100001x01xxxxxxxxxxxxxxxx1xxxx
 522                                          umops.  */
 523                                       return 2378;
 524                                     }
 525                                 }
 526                               else
 527                                 {
 528                                   /* 33222222222211111111110000000000
 529                                      10987654321098765432109876543210
 530                                      xxx00001x11xxxxxxxxxxxxxxxx1xxxx
 531                                      umops.  */
 532                                   return 2379;
 533                                 }
 534                             }
 535                         }
 536                     }
 537                   else
 538                     {
 539                       if (((word >> 29) & 0x1) == 0)
 540                         {
 541                           if (((word >> 30) & 0x1) == 0)
 542                             {
 543                               /* 33222222222211111111110000000000
 544                                  10987654321098765432109876543210
 545                                  x0010001xxxxxxxxxxxxxxxxxxxxxxxx
 546                                  add.  */
 547                               return 12;
 548                             }
 549                           else
 550                             {
 551                               /* 33222222222211111111110000000000
 552                                  10987654321098765432109876543210
 553                                  x1010001xxxxxxxxxxxxxxxxxxxxxxxx
 554                                  sub.  */
 555                               return 16;
 556                             }
 557                         }
 558                       else
 559                         {
 560                           if (((word >> 30) & 0x1) == 0)
 561                             {
 562                               /* 33222222222211111111110000000000
 563                                  10987654321098765432109876543210
 564                                  x0110001xxxxxxxxxxxxxxxxxxxxxxxx
 565                                  adds.  */
 566                               return 14;
 567                             }
 568                           else
 569                             {
 570                               /* 33222222222211111111110000000000
 571                                  10987654321098765432109876543210
 572                                  x1110001xxxxxxxxxxxxxxxxxxxxxxxx
 573                                  subs.  */
 574                               return 17;
 575                             }
 576                         }
 577                     }
 578                 }
 579             }
 580           else
 581             {
 582               if (((word >> 28) & 0x1) == 0)
 583                 {
 584                   if (((word >> 22) & 0x1) == 0)
 585                     {
 586                       if (((word >> 23) & 0x1) == 0)
 587                         {
 588                           if (((word >> 29) & 0x1) == 0)
 589                             {
 590                               if (((word >> 15) & 0x1) == 0)
 591                                 {
 592                                   if (((word >> 21) & 0x1) == 0)
 593                                     {
 594                                       if (((word >> 31) & 0x1) == 0)
 595                                         {
 596                                           if (((word >> 30) & 0x1) == 0)
 597                                             {
 598                                               /* 33222222222211111111110000000000
 599                                                  10987654321098765432109876543210
 600                                                  0000100x000xxxxx0xxxxxxxxxxxxxxx
 601                                                  stxrb.  */
 602                                               return 937;
 603                                             }
 604                                           else
 605                                             {
 606                                               /* 33222222222211111111110000000000
 607                                                  10987654321098765432109876543210
 608                                                  0100100x000xxxxx0xxxxxxxxxxxxxxx
 609                                                  stxrh.  */
 610                                               return 943;
 611                                             }
 612                                         }
 613                                       else
 614                                         {
 615                                           /* 33222222222211111111110000000000
 616                                              10987654321098765432109876543210
 617                                              1x00100x000xxxxx0xxxxxxxxxxxxxxx
 618                                              stxr.  */
 619                                           return 949;
 620                                         }
 621                                     }
 622                                   else
 623                                     {
 624                                       if (((word >> 31) & 0x1) == 0)
 625                                         {
 626                                           /* 33222222222211111111110000000000
 627                                              10987654321098765432109876543210
 628                                              0x00100x001xxxxx0xxxxxxxxxxxxxxx
 629                                              casp.  */
 630                                           return 1026;
 631                                         }
 632                                       else
 633                                         {
 634                                           /* 33222222222211111111110000000000
 635                                              10987654321098765432109876543210
 636                                              1x00100x001xxxxx0xxxxxxxxxxxxxxx
 637                                              stxp.  */
 638                                           return 951;
 639                                         }
 640                                     }
 641                                 }
 642                               else
 643                                 {
 644                                   if (((word >> 21) & 0x1) == 0)
 645                                     {
 646                                       if (((word >> 31) & 0x1) == 0)
 647                                         {
 648                                           if (((word >> 30) & 0x1) == 0)
 649                                             {
 650                                               /* 33222222222211111111110000000000
 651                                                  10987654321098765432109876543210
 652                                                  0000100x000xxxxx1xxxxxxxxxxxxxxx
 653                                                  stlxrb.  */
 654                                               return 938;
 655                                             }
 656                                           else
 657                                             {
 658                                               /* 33222222222211111111110000000000
 659                                                  10987654321098765432109876543210
 660                                                  0100100x000xxxxx1xxxxxxxxxxxxxxx
 661                                                  stlxrh.  */
 662                                               return 944;
 663                                             }
 664                                         }
 665                                       else
 666                                         {
 667                                           /* 33222222222211111111110000000000
 668                                              10987654321098765432109876543210
 669                                              1x00100x000xxxxx1xxxxxxxxxxxxxxx
 670                                              stlxr.  */
 671                                           return 950;
 672                                         }
 673                                     }
 674                                   else
 675                                     {
 676                                       if (((word >> 31) & 0x1) == 0)
 677                                         {
 678                                           /* 33222222222211111111110000000000
 679                                              10987654321098765432109876543210
 680                                              0x00100x001xxxxx1xxxxxxxxxxxxxxx
 681                                              caspl.  */
 682                                           return 1028;
 683                                         }
 684                                       else
 685                                         {
 686                                           /* 33222222222211111111110000000000
 687                                              10987654321098765432109876543210
 688                                              1x00100x001xxxxx1xxxxxxxxxxxxxxx
 689                                              stlxp.  */
 690                                           return 952;
 691                                         }
 692                                     }
 693                                 }
 694                             }
 695                           else
 696                             {
 697                               if (((word >> 30) & 0x1) == 0)
 698                                 {
 699                                   /* 33222222222211111111110000000000
 700                                      10987654321098765432109876543210
 701                                      x010100x00xxxxxxxxxxxxxxxxxxxxxx
 702                                      stnp.  */
 703                                   return 971;
 704                                 }
 705                               else
 706                                 {
 707                                   /* 33222222222211111111110000000000
 708                                      10987654321098765432109876543210
 709                                      x110100x00xxxxxxxxxxxxxxxxxxxxxx
 710                                      stgp.  */
 711                                   return 980;
 712                                 }
 713                             }
 714                         }
 715                       else
 716                         {
 717                           if (((word >> 29) & 0x1) == 0)
 718                             {
 719                               if (((word >> 15) & 0x1) == 0)
 720                                 {
 721                                   if (((word >> 21) & 0x1) == 0)
 722                                     {
 723                                       if (((word >> 31) & 0x1) == 0)
 724                                         {
 725                                           /* 33222222222211111111110000000000
 726                                              10987654321098765432109876543210
 727                                              0x00100x100xxxxx0xxxxxxxxxxxxxxx
 728                                              stllrb.  */
 729                                           return 969;
 730                                         }
 731                                       else
 732                                         {
 733                                           /* 33222222222211111111110000000000
 734                                              10987654321098765432109876543210
 735                                              1x00100x100xxxxx0xxxxxxxxxxxxxxx
 736                                              stllr.  */
 737                                           return 968;
 738                                         }
 739                                     }
 740                                   else
 741                                     {
 742                                       if (((word >> 31) & 0x1) == 0)
 743                                         {
 744                                           if (((word >> 30) & 0x1) == 0)
 745                                             {
 746                                               /* 33222222222211111111110000000000
 747                                                  10987654321098765432109876543210
 748                                                  0000100x101xxxxx0xxxxxxxxxxxxxxx
 749                                                  casb.  */
 750                                               return 1014;
 751                                             }
 752                                           else
 753                                             {
 754                                               /* 33222222222211111111110000000000
 755                                                  10987654321098765432109876543210
 756                                                  0100100x101xxxxx0xxxxxxxxxxxxxxx
 757                                                  cash.  */
 758                                               return 1015;
 759                                             }
 760                                         }
 761                                       else
 762                                         {
 763                                           /* 33222222222211111111110000000000
 764                                              10987654321098765432109876543210
 765                                              1x00100x101xxxxx0xxxxxxxxxxxxxxx
 766                                              cas.  */
 767                                           return 1016;
 768                                         }
 769                                     }
 770                                 }
 771                               else
 772                                 {
 773                                   if (((word >> 21) & 0x1) == 0)
 774                                     {
 775                                       if (((word >> 31) & 0x1) == 0)
 776                                         {
 777                                           if (((word >> 30) & 0x1) == 0)
 778                                             {
 779                                               /* 33222222222211111111110000000000
 780                                                  10987654321098765432109876543210
 781                                                  0000100x100xxxxx1xxxxxxxxxxxxxxx
 782                                                  stlrb.  */
 783                                               return 941;
 784                                             }
 785                                           else
 786                                             {
 787                                               /* 33222222222211111111110000000000
 788                                                  10987654321098765432109876543210
 789                                                  0100100x100xxxxx1xxxxxxxxxxxxxxx
 790                                                  stlrh.  */
 791                                               return 947;
 792                                             }
 793                                         }
 794                                       else
 795                                         {
 796                                           /* 33222222222211111111110000000000
 797                                              10987654321098765432109876543210
 798                                              1x00100x100xxxxx1xxxxxxxxxxxxxxx
 799                                              stlr.  */
 800                                           return 957;
 801                                         }
 802                                     }
 803                                   else
 804                                     {
 805                                       if (((word >> 31) & 0x1) == 0)
 806                                         {
 807                                           if (((word >> 30) & 0x1) == 0)
 808                                             {
 809                                               /* 33222222222211111111110000000000
 810                                                  10987654321098765432109876543210
 811                                                  0000100x101xxxxx1xxxxxxxxxxxxxxx
 812                                                  caslb.  */
 813                                               return 1018;
 814                                             }
 815                                           else
 816                                             {
 817                                               /* 33222222222211111111110000000000
 818                                                  10987654321098765432109876543210
 819                                                  0100100x101xxxxx1xxxxxxxxxxxxxxx
 820                                                  caslh.  */
 821                                               return 1021;
 822                                             }
 823                                         }
 824                                       else
 825                                         {
 826                                           /* 33222222222211111111110000000000
 827                                              10987654321098765432109876543210
 828                                              1x00100x101xxxxx1xxxxxxxxxxxxxxx
 829                                              casl.  */
 830                                           return 1024;
 831                                         }
 832                                     }
 833                                 }
 834                             }
 835                           else
 836                             {
 837                               if (((word >> 30) & 0x1) == 0)
 838                                 {
 839                                   /* 33222222222211111111110000000000
 840                                      10987654321098765432109876543210
 841                                      x010100x10xxxxxxxxxxxxxxxxxxxxxx
 842                                      stp.  */
 843                                   return 981;
 844                                 }
 845                               else
 846                                 {
 847                                   /* 33222222222211111111110000000000
 848                                      10987654321098765432109876543210
 849                                      x110100x10xxxxxxxxxxxxxxxxxxxxxx
 850                                      stgp.  */
 851                                   return 986;
 852                                 }
 853                             }
 854                         }
 855                     }
 856                   else
 857                     {
 858                       if (((word >> 23) & 0x1) == 0)
 859                         {
 860                           if (((word >> 29) & 0x1) == 0)
 861                             {
 862                               if (((word >> 15) & 0x1) == 0)
 863                                 {
 864                                   if (((word >> 21) & 0x1) == 0)
 865                                     {
 866                                       if (((word >> 31) & 0x1) == 0)
 867                                         {
 868                                           if (((word >> 30) & 0x1) == 0)
 869                                             {
 870                                               /* 33222222222211111111110000000000
 871                                                  10987654321098765432109876543210
 872                                                  0000100x010xxxxx0xxxxxxxxxxxxxxx
 873                                                  ldxrb.  */
 874                                               return 939;
 875                                             }
 876                                           else
 877                                             {
 878                                               /* 33222222222211111111110000000000
 879                                                  10987654321098765432109876543210
 880                                                  0100100x010xxxxx0xxxxxxxxxxxxxxx
 881                                                  ldxrh.  */
 882                                               return 945;
 883                                             }
 884                                         }
 885                                       else
 886                                         {
 887                                           /* 33222222222211111111110000000000
 888                                              10987654321098765432109876543210
 889                                              1x00100x010xxxxx0xxxxxxxxxxxxxxx
 890                                              ldxr.  */
 891                                           return 953;
 892                                         }
 893                                     }
 894                                   else
 895                                     {
 896                                       if (((word >> 31) & 0x1) == 0)
 897                                         {
 898                                           /* 33222222222211111111110000000000
 899                                              10987654321098765432109876543210
 900                                              0x00100x011xxxxx0xxxxxxxxxxxxxxx
 901                                              caspa.  */
 902                                           return 1027;
 903                                         }
 904                                       else
 905                                         {
 906                                           /* 33222222222211111111110000000000
 907                                              10987654321098765432109876543210
 908                                              1x00100x011xxxxx0xxxxxxxxxxxxxxx
 909                                              ldxp.  */
 910                                           return 955;
 911                                         }
 912                                     }
 913                                 }
 914                               else
 915                                 {
 916                                   if (((word >> 21) & 0x1) == 0)
 917                                     {
 918                                       if (((word >> 31) & 0x1) == 0)
 919                                         {
 920                                           if (((word >> 30) & 0x1) == 0)
 921                                             {
 922                                               /* 33222222222211111111110000000000
 923                                                  10987654321098765432109876543210
 924                                                  0000100x010xxxxx1xxxxxxxxxxxxxxx
 925                                                  ldaxrb.  */
 926                                               return 940;
 927                                             }
 928                                           else
 929                                             {
 930                                               /* 33222222222211111111110000000000
 931                                                  10987654321098765432109876543210
 932                                                  0100100x010xxxxx1xxxxxxxxxxxxxxx
 933                                                  ldaxrh.  */
 934                                               return 946;
 935                                             }
 936                                         }
 937                                       else
 938                                         {
 939                                           /* 33222222222211111111110000000000
 940                                              10987654321098765432109876543210
 941                                              1x00100x010xxxxx1xxxxxxxxxxxxxxx
 942                                              ldaxr.  */
 943                                           return 954;
 944                                         }
 945                                     }
 946                                   else
 947                                     {
 948                                       if (((word >> 31) & 0x1) == 0)
 949                                         {
 950                                           /* 33222222222211111111110000000000
 951                                              10987654321098765432109876543210
 952                                              0x00100x011xxxxx1xxxxxxxxxxxxxxx
 953                                              caspal.  */
 954                                           return 1029;
 955                                         }
 956                                       else
 957                                         {
 958                                           /* 33222222222211111111110000000000
 959                                              10987654321098765432109876543210
 960                                              1x00100x011xxxxx1xxxxxxxxxxxxxxx
 961                                              ldaxp.  */
 962                                           return 956;
 963                                         }
 964                                     }
 965                                 }
 966                             }
 967                           else
 968                             {
 969                               if (((word >> 30) & 0x1) == 0)
 970                                 {
 971                                   /* 33222222222211111111110000000000
 972                                      10987654321098765432109876543210
 973                                      x010100x01xxxxxxxxxxxxxxxxxxxxxx
 974                                      ldnp.  */
 975                                   return 972;
 976                                 }
 977                               else
 978                                 {
 979                                   /* 33222222222211111111110000000000
 980                                      10987654321098765432109876543210
 981                                      x110100x01xxxxxxxxxxxxxxxxxxxxxx
 982                                      ldpsw.  */
 983                                   return 979;
 984                                 }
 985                             }
 986                         }
 987                       else
 988                         {
 989                           if (((word >> 29) & 0x1) == 0)
 990                             {
 991                               if (((word >> 15) & 0x1) == 0)
 992                                 {
 993                                   if (((word >> 21) & 0x1) == 0)
 994                                     {
 995                                       if (((word >> 31) & 0x1) == 0)
 996                                         {
 997                                           if (((word >> 30) & 0x1) == 0)
 998                                             {
 999                                               /* 33222222222211111111110000000000
1000                                                  10987654321098765432109876543210
1001                                                  0000100x110xxxxx0xxxxxxxxxxxxxxx
1002                                                  ldlarb.  */
1003                                               return 966;
1004                                             }
1005                                           else
1006                                             {
1007                                               /* 33222222222211111111110000000000
1008                                                  10987654321098765432109876543210
1009                                                  0100100x110xxxxx0xxxxxxxxxxxxxxx
1010                                                  ldlarh.  */
1011                                               return 967;
1012                                             }
1013                                         }
1014                                       else
1015                                         {
1016                                           /* 33222222222211111111110000000000
1017                                              10987654321098765432109876543210
1018                                              1x00100x110xxxxx0xxxxxxxxxxxxxxx
1019                                              ldlar.  */
1020                                           return 965;
1021                                         }
1022                                     }
1023                                   else
1024                                     {
1025                                       if (((word >> 31) & 0x1) == 0)
1026                                         {
1027                                           if (((word >> 30) & 0x1) == 0)
1028                                             {
1029                                               /* 33222222222211111111110000000000
1030                                                  10987654321098765432109876543210
1031                                                  0000100x111xxxxx0xxxxxxxxxxxxxxx
1032                                                  casab.  */
1033                                               return 1017;
1034                                             }
1035                                           else
1036                                             {
1037                                               /* 33222222222211111111110000000000
1038                                                  10987654321098765432109876543210
1039                                                  0100100x111xxxxx0xxxxxxxxxxxxxxx
1040                                                  casah.  */
1041                                               return 1020;
1042                                             }
1043                                         }
1044                                       else
1045                                         {
1046                                           /* 33222222222211111111110000000000
1047                                              10987654321098765432109876543210
1048                                              1x00100x111xxxxx0xxxxxxxxxxxxxxx
1049                                              casa.  */
1050                                           return 1023;
1051                                         }
1052                                     }
1053                                 }
1054                               else
1055                                 {
1056                                   if (((word >> 21) & 0x1) == 0)
1057                                     {
1058                                       if (((word >> 31) & 0x1) == 0)
1059                                         {
1060                                           if (((word >> 30) & 0x1) == 0)
1061                                             {
1062                                               /* 33222222222211111111110000000000
1063                                                  10987654321098765432109876543210
1064                                                  0000100x110xxxxx1xxxxxxxxxxxxxxx
1065                                                  ldarb.  */
1066                                               return 942;
1067                                             }
1068                                           else
1069                                             {
1070                                               /* 33222222222211111111110000000000
1071                                                  10987654321098765432109876543210
1072                                                  0100100x110xxxxx1xxxxxxxxxxxxxxx
1073                                                  ldarh.  */
1074                                               return 948;
1075                                             }
1076                                         }
1077                                       else
1078                                         {
1079                                           /* 33222222222211111111110000000000
1080                                              10987654321098765432109876543210
1081                                              1x00100x110xxxxx1xxxxxxxxxxxxxxx
1082                                              ldar.  */
1083                                           return 958;
1084                                         }
1085                                     }
1086                                   else
1087                                     {
1088                                       if (((word >> 31) & 0x1) == 0)
1089                                         {
1090                                           if (((word >> 30) & 0x1) == 0)
1091                                             {
1092                                               /* 33222222222211111111110000000000
1093                                                  10987654321098765432109876543210
1094                                                  0000100x111xxxxx1xxxxxxxxxxxxxxx
1095                                                  casalb.  */
1096                                               return 1019;
1097                                             }
1098                                           else
1099                                             {
1100                                               /* 33222222222211111111110000000000
1101                                                  10987654321098765432109876543210
1102                                                  0100100x111xxxxx1xxxxxxxxxxxxxxx
1103                                                  casalh.  */
1104                                               return 1022;
1105                                             }
1106                                         }
1107                                       else
1108                                         {
1109                                           /* 33222222222211111111110000000000
1110                                              10987654321098765432109876543210
1111                                              1x00100x111xxxxx1xxxxxxxxxxxxxxx
1112                                              casal.  */
1113                                           return 1025;
1114                                         }
1115                                     }
1116                                 }
1117                             }
1118                           else
1119                             {
1120                               if (((word >> 30) & 0x1) == 0)
1121                                 {
1122                                   /* 33222222222211111111110000000000
1123                                      10987654321098765432109876543210
1124                                      x010100x11xxxxxxxxxxxxxxxxxxxxxx
1125                                      ldp.  */
1126                                   return 982;
1127                                 }
1128                               else
1129                                 {
1130                                   /* 33222222222211111111110000000000
1131                                      10987654321098765432109876543210
1132                                      x110100x11xxxxxxxxxxxxxxxxxxxxxx
1133                                      ldpsw.  */
1134                                   return 985;
1135                                 }
1136                             }
1137                         }
1138                     }
1139                 }
1140               else
1141                 {
1142                   if (((word >> 24) & 0x1) == 0)
1143                     {
1144                       if (((word >> 29) & 0x1) == 0)
1145                         {
1146                           if (((word >> 31) & 0x1) == 0)
1147                             {
1148                               /* 33222222222211111111110000000000
1149                                  10987654321098765432109876543210
1150                                  0x011000xxxxxxxxxxxxxxxxxxxxxxxx
1151                                  ldr.  */
1152                               return 987;
1153                             }
1154                           else
1155                             {
1156                               if (((word >> 30) & 0x1) == 0)
1157                                 {
1158                                   /* 33222222222211111111110000000000
1159                                      10987654321098765432109876543210
1160                                      10011000xxxxxxxxxxxxxxxxxxxxxxxx
1161                                      ldrsw.  */
1162                                   return 989;
1163                                 }
1164                               else
1165                                 {
1166                                   /* 33222222222211111111110000000000
1167                                      10987654321098765432109876543210
1168                                      11011000xxxxxxxxxxxxxxxxxxxxxxxx
1169                                      prfm.  */
1170                                   return 990;
1171                                 }
1172                             }
1173                         }
1174                       else
1175                         {
1176                           if (((word >> 10) & 0x1) == 0)
1177                             {
1178                               if (((word >> 11) & 0x1) == 0)
1179                                 {
1180                                   if (((word >> 21) & 0x1) == 0)
1181                                     {
1182                                       if (((word >> 23) & 0x1) == 0)
1183                                         {
1184                                           if (((word >> 22) & 0x1) == 0)
1185                                             {
1186                                               if (((word >> 31) & 0x1) == 0)
1187                                                 {
1188                                                   if (((word >> 30) & 0x1) == 0)
1189                                                     {
1190                                                       /* 33222222222211111111110000000000
1191                                                          10987654321098765432109876543210
1192                                                          00111000000xxxxxxxxx00xxxxxxxxxx
1193                                                          sturb.  */
1194                                                       return 922;
1195                                                     }
1196                                                   else
1197                                                     {
1198                                                       /* 33222222222211111111110000000000
1199                                                          10987654321098765432109876543210
1200                                                          01111000000xxxxxxxxx00xxxxxxxxxx
1201                                                          sturh.  */
1202                                                       return 927;
1203                                                     }
1204                                                 }
1205                                               else
1206                                                 {
1207                                                   /* 33222222222211111111110000000000
1208                                                      10987654321098765432109876543210
1209                                                      1x111000000xxxxxxxxx00xxxxxxxxxx
1210                                                      stur.  */
1211                                                   return 930;
1212                                                 }
1213                                             }
1214                                           else
1215                                             {
1216                                               if (((word >> 31) & 0x1) == 0)
1217                                                 {
1218                                                   if (((word >> 30) & 0x1) == 0)
1219                                                     {
1220                                                       /* 33222222222211111111110000000000
1221                                                          10987654321098765432109876543210
1222                                                          00111000010xxxxxxxxx00xxxxxxxxxx
1223                                                          ldurb.  */
1224                                                       return 923;
1225                                                     }
1226                                                   else
1227                                                     {
1228                                                       /* 33222222222211111111110000000000
1229                                                          10987654321098765432109876543210
1230                                                          01111000010xxxxxxxxx00xxxxxxxxxx
1231                                                          ldurh.  */
1232                                                       return 928;
1233                                                     }
1234                                                 }
1235                                               else
1236                                                 {
1237                                                   /* 33222222222211111111110000000000
1238                                                      10987654321098765432109876543210
1239                                                      1x111000010xxxxxxxxx00xxxxxxxxxx
1240                                                      ldur.  */
1241                                                   return 931;
1242                                                 }
1243                                             }
1244                                         }
1245                                       else
1246                                         {
1247                                           if (((word >> 30) & 0x1) == 0)
1248                                             {
1249                                               if (((word >> 31) & 0x1) == 0)
1250                                                 {
1251                                                   /* 33222222222211111111110000000000
1252                                                      10987654321098765432109876543210
1253                                                      001110001x0xxxxxxxxx00xxxxxxxxxx
1254                                                      ldursb.  */
1255                                                   return 924;
1256                                                 }
1257                                               else
1258                                                 {
1259                                                   /* 33222222222211111111110000000000
1260                                                      10987654321098765432109876543210
1261                                                      101110001x0xxxxxxxxx00xxxxxxxxxx
1262                                                      ldursw.  */
1263                                                   return 932;
1264                                                 }
1265                                             }
1266                                           else
1267                                             {
1268                                               if (((word >> 31) & 0x1) == 0)
1269                                                 {
1270                                                   /* 33222222222211111111110000000000
1271                                                      10987654321098765432109876543210
1272                                                      011110001x0xxxxxxxxx00xxxxxxxxxx
1273                                                      ldursh.  */
1274                                                   return 929;
1275                                                 }
1276                                               else
1277                                                 {
1278                                                   /* 33222222222211111111110000000000
1279                                                      10987654321098765432109876543210
1280                                                      111110001x0xxxxxxxxx00xxxxxxxxxx
1281                                                      prfum.  */
1282                                                   return 933;
1283                                                 }
1284                                             }
1285                                         }
1286                                     }
1287                                   else
1288                                     {
1289                                       if (((word >> 12) & 0x1) == 0)
1290                                         {
1291                                           if (((word >> 13) & 0x1) == 0)
1292                                             {
1293                                               if (((word >> 14) & 0x1) == 0)
1294                                                 {
1295                                                   if (((word >> 15) & 0x1) == 0)
1296                                                     {
1297                                                       if (((word >> 22) & 0x1) == 0)
1298                                                         {
1299                                                           if (((word >> 23) & 0x1) == 0)
1300                                                             {
1301                                                               if (((word >> 31) & 0x1) == 0)
1302                                                                 {
1303                                                                   if (((word >> 30) & 0x1) == 0)
1304                                                                     {
1305                                                                       /* 33222222222211111111110000000000
1306                                                                          10987654321098765432109876543210
1307                                                                          00111000001xxxxx000000xxxxxxxxxx
1308                                                                          ldaddb.  */
1309                                                                       return 1042;
1310                                                                     }
1311                                                                   else
1312                                                                     {
1313                                                                       /* 33222222222211111111110000000000
1314                                                                          10987654321098765432109876543210
1315                                                                          01111000001xxxxx000000xxxxxxxxxx
1316                                                                          ldaddh.  */
1317                                                                       return 1043;
1318                                                                     }
1319                                                                 }
1320                                                               else
1321                                                                 {
1322                                                                   /* 33222222222211111111110000000000
1323                                                                      10987654321098765432109876543210
1324                                                                      1x111000001xxxxx000000xxxxxxxxxx
1325                                                                      ldadd.  */
1326                                                                   return 1044;
1327                                                                 }
1328                                                             }
1329                                                           else
1330                                                             {
1331                                                               if (((word >> 31) & 0x1) == 0)
1332                                                                 {
1333                                                                   if (((word >> 30) & 0x1) == 0)
1334                                                                     {
1335                                                                       /* 33222222222211111111110000000000
1336                                                                          10987654321098765432109876543210
1337                                                                          00111000101xxxxx000000xxxxxxxxxx
1338                                                                          ldaddab.  */
1339                                                                       return 1045;
1340                                                                     }
1341                                                                   else
1342                                                                     {
1343                                                                       /* 33222222222211111111110000000000
1344                                                                          10987654321098765432109876543210
1345                                                                          01111000101xxxxx000000xxxxxxxxxx
1346                                                                          ldaddah.  */
1347                                                                       return 1048;
1348                                                                     }
1349                                                                 }
1350                                                               else
1351                                                                 {
1352                                                                   /* 33222222222211111111110000000000
1353                                                                      10987654321098765432109876543210
1354                                                                      1x111000101xxxxx000000xxxxxxxxxx
1355                                                                      ldadda.  */
1356                                                                   return 1051;
1357                                                                 }
1358                                                             }
1359                                                         }
1360                                                       else
1361                                                         {
1362                                                           if (((word >> 23) & 0x1) == 0)
1363                                                             {
1364                                                               if (((word >> 31) & 0x1) == 0)
1365                                                                 {
1366                                                                   if (((word >> 30) & 0x1) == 0)
1367                                                                     {
1368                                                                       /* 33222222222211111111110000000000
1369                                                                          10987654321098765432109876543210
1370                                                                          00111000011xxxxx000000xxxxxxxxxx
1371                                                                          ldaddlb.  */
1372                                                                       return 1046;
1373                                                                     }
1374                                                                   else
1375                                                                     {
1376                                                                       /* 33222222222211111111110000000000
1377                                                                          10987654321098765432109876543210
1378                                                                          01111000011xxxxx000000xxxxxxxxxx
1379                                                                          ldaddlh.  */
1380                                                                       return 1049;
1381                                                                     }
1382                                                                 }
1383                                                               else
1384                                                                 {
1385                                                                   /* 33222222222211111111110000000000
1386                                                                      10987654321098765432109876543210
1387                                                                      1x111000011xxxxx000000xxxxxxxxxx
1388                                                                      ldaddl.  */
1389                                                                   return 1052;
1390                                                                 }
1391                                                             }
1392                                                           else
1393                                                             {
1394                                                               if (((word >> 31) & 0x1) == 0)
1395                                                                 {
1396                                                                   if (((word >> 30) & 0x1) == 0)
1397                                                                     {
1398                                                                       /* 33222222222211111111110000000000
1399                                                                          10987654321098765432109876543210
1400                                                                          00111000111xxxxx000000xxxxxxxxxx
1401                                                                          ldaddalb.  */
1402                                                                       return 1047;
1403                                                                     }
1404                                                                   else
1405                                                                     {
1406                                                                       /* 33222222222211111111110000000000
1407                                                                          10987654321098765432109876543210
1408                                                                          01111000111xxxxx000000xxxxxxxxxx
1409                                                                          ldaddalh.  */
1410                                                                       return 1050;
1411                                                                     }
1412                                                                 }
1413                                                               else
1414                                                                 {
1415                                                                   /* 33222222222211111111110000000000
1416                                                                      10987654321098765432109876543210
1417                                                                      1x111000111xxxxx000000xxxxxxxxxx
1418                                                                      ldaddal.  */
1419                                                                   return 1053;
1420                                                                 }
1421                                                             }
1422                                                         }
1423                                                     }
1424                                                   else
1425                                                     {
1426                                                       if (((word >> 22) & 0x1) == 0)
1427                                                         {
1428                                                           if (((word >> 23) & 0x1) == 0)
1429                                                             {
1430                                                               if (((word >> 31) & 0x1) == 0)
1431                                                                 {
1432                                                                   if (((word >> 30) & 0x1) == 0)
1433                                                                     {
1434                                                                       /* 33222222222211111111110000000000
1435                                                                          10987654321098765432109876543210
1436                                                                          00111000001xxxxx100000xxxxxxxxxx
1437                                                                          swpb.  */
1438                                                                       return 1030;
1439                                                                     }
1440                                                                   else
1441                                                                     {
1442                                                                       /* 33222222222211111111110000000000
1443                                                                          10987654321098765432109876543210
1444                                                                          01111000001xxxxx100000xxxxxxxxxx
1445                                                                          swph.  */
1446                                                                       return 1031;
1447                                                                     }
1448                                                                 }
1449                                                               else
1450                                                                 {
1451                                                                   /* 33222222222211111111110000000000
1452                                                                      10987654321098765432109876543210
1453                                                                      1x111000001xxxxx100000xxxxxxxxxx
1454                                                                      swp.  */
1455                                                                   return 1032;
1456                                                                 }
1457                                                             }
1458                                                           else
1459                                                             {
1460                                                               if (((word >> 31) & 0x1) == 0)
1461                                                                 {
1462                                                                   if (((word >> 30) & 0x1) == 0)
1463                                                                     {
1464                                                                       /* 33222222222211111111110000000000
1465                                                                          10987654321098765432109876543210
1466                                                                          00111000101xxxxx100000xxxxxxxxxx
1467                                                                          swpab.  */
1468                                                                       return 1033;
1469                                                                     }
1470                                                                   else
1471                                                                     {
1472                                                                       /* 33222222222211111111110000000000
1473                                                                          10987654321098765432109876543210
1474                                                                          01111000101xxxxx100000xxxxxxxxxx
1475                                                                          swpah.  */
1476                                                                       return 1036;
1477                                                                     }
1478                                                                 }
1479                                                               else
1480                                                                 {
1481                                                                   /* 33222222222211111111110000000000
1482                                                                      10987654321098765432109876543210
1483                                                                      1x111000101xxxxx100000xxxxxxxxxx
1484                                                                      swpa.  */
1485                                                                   return 1039;
1486                                                                 }
1487                                                             }
1488                                                         }
1489                                                       else
1490                                                         {
1491                                                           if (((word >> 23) & 0x1) == 0)
1492                                                             {
1493                                                               if (((word >> 31) & 0x1) == 0)
1494                                                                 {
1495                                                                   if (((word >> 30) & 0x1) == 0)
1496                                                                     {
1497                                                                       /* 33222222222211111111110000000000
1498                                                                          10987654321098765432109876543210
1499                                                                          00111000011xxxxx100000xxxxxxxxxx
1500                                                                          swplb.  */
1501                                                                       return 1034;
1502                                                                     }
1503                                                                   else
1504                                                                     {
1505                                                                       /* 33222222222211111111110000000000
1506                                                                          10987654321098765432109876543210
1507                                                                          01111000011xxxxx100000xxxxxxxxxx
1508                                                                          swplh.  */
1509                                                                       return 1037;
1510                                                                     }
1511                                                                 }
1512                                                               else
1513                                                                 {
1514                                                                   /* 33222222222211111111110000000000
1515                                                                      10987654321098765432109876543210
1516                                                                      1x111000011xxxxx100000xxxxxxxxxx
1517                                                                      swpl.  */
1518                                                                   return 1040;
1519                                                                 }
1520                                                             }
1521                                                           else
1522                                                             {
1523                                                               if (((word >> 31) & 0x1) == 0)
1524                                                                 {
1525                                                                   if (((word >> 30) & 0x1) == 0)
1526                                                                     {
1527                                                                       /* 33222222222211111111110000000000
1528                                                                          10987654321098765432109876543210
1529                                                                          00111000111xxxxx100000xxxxxxxxxx
1530                                                                          swpalb.  */
1531                                                                       return 1035;
1532                                                                     }
1533                                                                   else
1534                                                                     {
1535                                                                       /* 33222222222211111111110000000000
1536                                                                          10987654321098765432109876543210
1537                                                                          01111000111xxxxx100000xxxxxxxxxx
1538                                                                          swpalh.  */
1539                                                                       return 1038;
1540                                                                     }
1541                                                                 }
1542                                                               else
1543                                                                 {
1544                                                                   /* 33222222222211111111110000000000
1545                                                                      10987654321098765432109876543210
1546                                                                      1x111000111xxxxx100000xxxxxxxxxx
1547                                                                      swpal.  */
1548                                                                   return 1041;
1549                                                                 }
1550                                                             }
1551                                                         }
1552                                                     }
1553                                                 }
1554                                               else
1555                                                 {
1556                                                   if (((word >> 15) & 0x1) == 0)
1557                                                     {
1558                                                       if (((word >> 22) & 0x1) == 0)
1559                                                         {
1560                                                           if (((word >> 23) & 0x1) == 0)
1561                                                             {
1562                                                               if (((word >> 31) & 0x1) == 0)
1563                                                                 {
1564                                                                   if (((word >> 30) & 0x1) == 0)
1565                                                                     {
1566                                                                       /* 33222222222211111111110000000000
1567                                                                          10987654321098765432109876543210
1568                                                                          00111000001xxxxx010000xxxxxxxxxx
1569                                                                          ldsmaxb.  */
1570                                                                       return 1090;
1571                                                                     }
1572                                                                   else
1573                                                                     {
1574                                                                       /* 33222222222211111111110000000000
1575                                                                          10987654321098765432109876543210
1576                                                                          01111000001xxxxx010000xxxxxxxxxx
1577                                                                          ldsmaxh.  */
1578                                                                       return 1091;
1579                                                                     }
1580                                                                 }
1581                                                               else
1582                                                                 {
1583                                                                   /* 33222222222211111111110000000000
1584                                                                      10987654321098765432109876543210
1585                                                                      1x111000001xxxxx010000xxxxxxxxxx
1586                                                                      ldsmax.  */
1587                                                                   return 1092;
1588                                                                 }
1589                                                             }
1590                                                           else
1591                                                             {
1592                                                               if (((word >> 31) & 0x1) == 0)
1593                                                                 {
1594                                                                   if (((word >> 30) & 0x1) == 0)
1595                                                                     {
1596                                                                       /* 33222222222211111111110000000000
1597                                                                          10987654321098765432109876543210
1598                                                                          00111000101xxxxx010000xxxxxxxxxx
1599                                                                          ldsmaxab.  */
1600                                                                       return 1093;
1601                                                                     }
1602                                                                   else
1603                                                                     {
1604                                                                       /* 33222222222211111111110000000000
1605                                                                          10987654321098765432109876543210
1606                                                                          01111000101xxxxx010000xxxxxxxxxx
1607                                                                          ldsmaxah.  */
1608                                                                       return 1096;
1609                                                                     }
1610                                                                 }
1611                                                               else
1612                                                                 {
1613                                                                   /* 33222222222211111111110000000000
1614                                                                      10987654321098765432109876543210
1615                                                                      1x111000101xxxxx010000xxxxxxxxxx
1616                                                                      ldsmaxa.  */
1617                                                                   return 1099;
1618                                                                 }
1619                                                             }
1620                                                         }
1621                                                       else
1622                                                         {
1623                                                           if (((word >> 23) & 0x1) == 0)
1624                                                             {
1625                                                               if (((word >> 31) & 0x1) == 0)
1626                                                                 {
1627                                                                   if (((word >> 30) & 0x1) == 0)
1628                                                                     {
1629                                                                       /* 33222222222211111111110000000000
1630                                                                          10987654321098765432109876543210
1631                                                                          00111000011xxxxx010000xxxxxxxxxx
1632                                                                          ldsmaxlb.  */
1633                                                                       return 1094;
1634                                                                     }
1635                                                                   else
1636                                                                     {
1637                                                                       /* 33222222222211111111110000000000
1638                                                                          10987654321098765432109876543210
1639                                                                          01111000011xxxxx010000xxxxxxxxxx
1640                                                                          ldsmaxlh.  */
1641                                                                       return 1097;
1642                                                                     }
1643                                                                 }
1644                                                               else
1645                                                                 {
1646                                                                   /* 33222222222211111111110000000000
1647                                                                      10987654321098765432109876543210
1648                                                                      1x111000011xxxxx010000xxxxxxxxxx
1649                                                                      ldsmaxl.  */
1650                                                                   return 1100;
1651                                                                 }
1652                                                             }
1653                                                           else
1654                                                             {
1655                                                               if (((word >> 31) & 0x1) == 0)
1656                                                                 {
1657                                                                   if (((word >> 30) & 0x1) == 0)
1658                                                                     {
1659                                                                       /* 33222222222211111111110000000000
1660                                                                          10987654321098765432109876543210
1661                                                                          00111000111xxxxx010000xxxxxxxxxx
1662                                                                          ldsmaxalb.  */
1663                                                                       return 1095;
1664                                                                     }
1665                                                                   else
1666                                                                     {
1667                                                                       /* 33222222222211111111110000000000
1668                                                                          10987654321098765432109876543210
1669                                                                          01111000111xxxxx010000xxxxxxxxxx
1670                                                                          ldsmaxalh.  */
1671                                                                       return 1098;
1672                                                                     }
1673                                                                 }
1674                                                               else
1675                                                                 {
1676                                                                   /* 33222222222211111111110000000000
1677                                                                      10987654321098765432109876543210
1678                                                                      1x111000111xxxxx010000xxxxxxxxxx
1679                                                                      ldsmaxal.  */
1680                                                                   return 1101;
1681                                                                 }
1682                                                             }
1683                                                         }
1684                                                     }
1685                                                   else
1686                                                     {
1687                                                       if (((word >> 31) & 0x1) == 0)
1688                                                         {
1689                                                           if (((word >> 30) & 0x1) == 0)
1690                                                             {
1691                                                               /* 33222222222211111111110000000000
1692                                                                  10987654321098765432109876543210
1693                                                                  00111000xx1xxxxx110000xxxxxxxxxx
1694                                                                  ldaprb.  */
1695                                                               return 959;
1696                                                             }
1697                                                           else
1698                                                             {
1699                                                               /* 33222222222211111111110000000000
1700                                                                  10987654321098765432109876543210
1701                                                                  01111000xx1xxxxx110000xxxxxxxxxx
1702                                                                  ldaprh.  */
1703                                                               return 960;
1704                                                             }
1705                                                         }
1706                                                       else
1707                                                         {
1708                                                           /* 33222222222211111111110000000000
1709                                                              10987654321098765432109876543210
1710                                                              1x111000xx1xxxxx110000xxxxxxxxxx
1711                                                              ldapr.  */
1712                                                           return 961;
1713                                                         }
1714                                                     }
1715                                                 }
1716                                             }
1717                                           else
1718                                             {
1719                                               if (((word >> 14) & 0x1) == 0)
1720                                                 {
1721                                                   if (((word >> 15) & 0x1) == 0)
1722                                                     {
1723                                                       if (((word >> 22) & 0x1) == 0)
1724                                                         {
1725                                                           if (((word >> 23) & 0x1) == 0)
1726                                                             {
1727                                                               if (((word >> 31) & 0x1) == 0)
1728                                                                 {
1729                                                                   if (((word >> 30) & 0x1) == 0)
1730                                                                     {
1731                                                                       /* 33222222222211111111110000000000
1732                                                                          10987654321098765432109876543210
1733                                                                          00111000001xxxxx001000xxxxxxxxxx
1734                                                                          ldeorb.  */
1735                                                                       return 1066;
1736                                                                     }
1737                                                                   else
1738                                                                     {
1739                                                                       /* 33222222222211111111110000000000
1740                                                                          10987654321098765432109876543210
1741                                                                          01111000001xxxxx001000xxxxxxxxxx
1742                                                                          ldeorh.  */
1743                                                                       return 1067;
1744                                                                     }
1745                                                                 }
1746                                                               else
1747                                                                 {
1748                                                                   /* 33222222222211111111110000000000
1749                                                                      10987654321098765432109876543210
1750                                                                      1x111000001xxxxx001000xxxxxxxxxx
1751                                                                      ldeor.  */
1752                                                                   return 1068;
1753                                                                 }
1754                                                             }
1755                                                           else
1756                                                             {
1757                                                               if (((word >> 31) & 0x1) == 0)
1758                                                                 {
1759                                                                   if (((word >> 30) & 0x1) == 0)
1760                                                                     {
1761                                                                       /* 33222222222211111111110000000000
1762                                                                          10987654321098765432109876543210
1763                                                                          00111000101xxxxx001000xxxxxxxxxx
1764                                                                          ldeorab.  */
1765                                                                       return 1069;
1766                                                                     }
1767                                                                   else
1768                                                                     {
1769                                                                       /* 33222222222211111111110000000000
1770                                                                          10987654321098765432109876543210
1771                                                                          01111000101xxxxx001000xxxxxxxxxx
1772                                                                          ldeorah.  */
1773                                                                       return 1072;
1774                                                                     }
1775                                                                 }
1776                                                               else
1777                                                                 {
1778                                                                   /* 33222222222211111111110000000000
1779                                                                      10987654321098765432109876543210
1780                                                                      1x111000101xxxxx001000xxxxxxxxxx
1781                                                                      ldeora.  */
1782                                                                   return 1075;
1783                                                                 }
1784                                                             }
1785                                                         }
1786                                                       else
1787                                                         {
1788                                                           if (((word >> 23) & 0x1) == 0)
1789                                                             {
1790                                                               if (((word >> 31) & 0x1) == 0)
1791                                                                 {
1792                                                                   if (((word >> 30) & 0x1) == 0)
1793                                                                     {
1794                                                                       /* 33222222222211111111110000000000
1795                                                                          10987654321098765432109876543210
1796                                                                          00111000011xxxxx001000xxxxxxxxxx
1797                                                                          ldeorlb.  */
1798                                                                       return 1070;
1799                                                                     }
1800                                                                   else
1801                                                                     {
1802                                                                       /* 33222222222211111111110000000000
1803                                                                          10987654321098765432109876543210
1804                                                                          01111000011xxxxx001000xxxxxxxxxx
1805                                                                          ldeorlh.  */
1806                                                                       return 1073;
1807                                                                     }
1808                                                                 }
1809                                                               else
1810                                                                 {
1811                                                                   /* 33222222222211111111110000000000
1812                                                                      10987654321098765432109876543210
1813                                                                      1x111000011xxxxx001000xxxxxxxxxx
1814                                                                      ldeorl.  */
1815                                                                   return 1076;
1816                                                                 }
1817                                                             }
1818                                                           else
1819                                                             {
1820                                                               if (((word >> 31) & 0x1) == 0)
1821                                                                 {
1822                                                                   if (((word >> 30) & 0x1) == 0)
1823                                                                     {
1824                                                                       /* 33222222222211111111110000000000
1825                                                                          10987654321098765432109876543210
1826                                                                          00111000111xxxxx001000xxxxxxxxxx
1827                                                                          ldeoralb.  */
1828                                                                       return 1071;
1829                                                                     }
1830                                                                   else
1831                                                                     {
1832                                                                       /* 33222222222211111111110000000000
1833                                                                          10987654321098765432109876543210
1834                                                                          01111000111xxxxx001000xxxxxxxxxx
1835                                                                          ldeoralh.  */
1836                                                                       return 1074;
1837                                                                     }
1838                                                                 }
1839                                                               else
1840                                                                 {
1841                                                                   /* 33222222222211111111110000000000
1842                                                                      10987654321098765432109876543210
1843                                                                      1x111000111xxxxx001000xxxxxxxxxx
1844                                                                      ldeoral.  */
1845                                                                   return 1077;
1846                                                                 }
1847                                                             }
1848                                                         }
1849                                                     }
1850                                                   else
1851                                                     {
1852                                                       /* 33222222222211111111110000000000
1853                                                          10987654321098765432109876543210
1854                                                          xx111000xx1xxxxx101000xxxxxxxxxx
1855                                                          st64bv0.  */
1856                                                       return 994;
1857                                                     }
1858                                                 }
1859                                               else
1860                                                 {
1861                                                   if (((word >> 22) & 0x1) == 0)
1862                                                     {
1863                                                       if (((word >> 23) & 0x1) == 0)
1864                                                         {
1865                                                           if (((word >> 31) & 0x1) == 0)
1866                                                             {
1867                                                               if (((word >> 30) & 0x1) == 0)
1868                                                                 {
1869                                                                   /* 33222222222211111111110000000000
1870                                                                      10987654321098765432109876543210
1871                                                                      00111000001xxxxxx11000xxxxxxxxxx
1872                                                                      ldumaxb.  */
1873                                                                   return 1114;
1874                                                                 }
1875                                                               else
1876                                                                 {
1877                                                                   /* 33222222222211111111110000000000
1878                                                                      10987654321098765432109876543210
1879                                                                      01111000001xxxxxx11000xxxxxxxxxx
1880                                                                      ldumaxh.  */
1881                                                                   return 1115;
1882                                                                 }
1883                                                             }
1884                                                           else
1885                                                             {
1886                                                               /* 33222222222211111111110000000000
1887                                                                  10987654321098765432109876543210
1888                                                                  1x111000001xxxxxx11000xxxxxxxxxx
1889                                                                  ldumax.  */
1890                                                               return 1116;
1891                                                             }
1892                                                         }
1893                                                       else
1894                                                         {
1895                                                           if (((word >> 31) & 0x1) == 0)
1896                                                             {
1897                                                               if (((word >> 30) & 0x1) == 0)
1898                                                                 {
1899                                                                   /* 33222222222211111111110000000000
1900                                                                      10987654321098765432109876543210
1901                                                                      00111000101xxxxxx11000xxxxxxxxxx
1902                                                                      ldumaxab.  */
1903                                                                   return 1117;
1904                                                                 }
1905                                                               else
1906                                                                 {
1907                                                                   /* 33222222222211111111110000000000
1908                                                                      10987654321098765432109876543210
1909                                                                      01111000101xxxxxx11000xxxxxxxxxx
1910                                                                      ldumaxah.  */
1911                                                                   return 1120;
1912                                                                 }
1913                                                             }
1914                                                           else
1915                                                             {
1916                                                               /* 33222222222211111111110000000000
1917                                                                  10987654321098765432109876543210
1918                                                                  1x111000101xxxxxx11000xxxxxxxxxx
1919                                                                  ldumaxa.  */
1920                                                               return 1123;
1921                                                             }
1922                                                         }
1923                                                     }
1924                                                   else
1925                                                     {
1926                                                       if (((word >> 23) & 0x1) == 0)
1927                                                         {
1928                                                           if (((word >> 31) & 0x1) == 0)
1929                                                             {
1930                                                               if (((word >> 30) & 0x1) == 0)
1931                                                                 {
1932                                                                   /* 33222222222211111111110000000000
1933                                                                      10987654321098765432109876543210
1934                                                                      00111000011xxxxxx11000xxxxxxxxxx
1935                                                                      ldumaxlb.  */
1936                                                                   return 1118;
1937                                                                 }
1938                                                               else
1939                                                                 {
1940                                                                   /* 33222222222211111111110000000000
1941                                                                      10987654321098765432109876543210
1942                                                                      01111000011xxxxxx11000xxxxxxxxxx
1943                                                                      ldumaxlh.  */
1944                                                                   return 1121;
1945                                                                 }
1946                                                             }
1947                                                           else
1948                                                             {
1949                                                               /* 33222222222211111111110000000000
1950                                                                  10987654321098765432109876543210
1951                                                                  1x111000011xxxxxx11000xxxxxxxxxx
1952                                                                  ldumaxl.  */
1953                                                               return 1124;
1954                                                             }
1955                                                         }
1956                                                       else
1957                                                         {
1958                                                           if (((word >> 31) & 0x1) == 0)
1959                                                             {
1960                                                               if (((word >> 30) & 0x1) == 0)
1961                                                                 {
1962                                                                   /* 33222222222211111111110000000000
1963                                                                      10987654321098765432109876543210
1964                                                                      00111000111xxxxxx11000xxxxxxxxxx
1965                                                                      ldumaxalb.  */
1966                                                                   return 1119;
1967                                                                 }
1968                                                               else
1969                                                                 {
1970                                                                   /* 33222222222211111111110000000000
1971                                                                      10987654321098765432109876543210
1972                                                                      01111000111xxxxxx11000xxxxxxxxxx
1973                                                                      ldumaxalh.  */
1974                                                                   return 1122;
1975                                                                 }
1976                                                             }
1977                                                           else
1978                                                             {
1979                                                               /* 33222222222211111111110000000000
1980                                                                  10987654321098765432109876543210
1981                                                                  1x111000111xxxxxx11000xxxxxxxxxx
1982                                                                  ldumaxal.  */
1983                                                               return 1125;
1984                                                             }
1985                                                         }
1986                                                     }
1987                                                 }
1988                                             }
1989                                         }
1990                                       else
1991                                         {
1992                                           if (((word >> 13) & 0x1) == 0)
1993                                             {
1994                                               if (((word >> 14) & 0x1) == 0)
1995                                                 {
1996                                                   if (((word >> 15) & 0x1) == 0)
1997                                                     {
1998                                                       if (((word >> 22) & 0x1) == 0)
1999                                                         {
2000                                                           if (((word >> 23) & 0x1) == 0)
2001                                                             {
2002                                                               if (((word >> 31) & 0x1) == 0)
2003                                                                 {
2004                                                                   if (((word >> 30) & 0x1) == 0)
2005                                                                     {
2006                                                                       /* 33222222222211111111110000000000
2007                                                                          10987654321098765432109876543210
2008                                                                          00111000001xxxxx000100xxxxxxxxxx
2009                                                                          ldclrb.  */
2010                                                                       return 1054;
2011                                                                     }
2012                                                                   else
2013                                                                     {
2014                                                                       /* 33222222222211111111110000000000
2015                                                                          10987654321098765432109876543210
2016                                                                          01111000001xxxxx000100xxxxxxxxxx
2017                                                                          ldclrh.  */
2018                                                                       return 1055;
2019                                                                     }
2020                                                                 }
2021                                                               else
2022                                                                 {
2023                                                                   /* 33222222222211111111110000000000
2024                                                                      10987654321098765432109876543210
2025                                                                      1x111000001xxxxx000100xxxxxxxxxx
2026                                                                      ldclr.  */
2027                                                                   return 1056;
2028                                                                 }
2029                                                             }
2030                                                           else
2031                                                             {
2032                                                               if (((word >> 31) & 0x1) == 0)
2033                                                                 {
2034                                                                   if (((word >> 30) & 0x1) == 0)
2035                                                                     {
2036                                                                       /* 33222222222211111111110000000000
2037                                                                          10987654321098765432109876543210
2038                                                                          00111000101xxxxx000100xxxxxxxxxx
2039                                                                          ldclrab.  */
2040                                                                       return 1057;
2041                                                                     }
2042                                                                   else
2043                                                                     {
2044                                                                       /* 33222222222211111111110000000000
2045                                                                          10987654321098765432109876543210
2046                                                                          01111000101xxxxx000100xxxxxxxxxx
2047                                                                          ldclrah.  */
2048                                                                       return 1060;
2049                                                                     }
2050                                                                 }
2051                                                               else
2052                                                                 {
2053                                                                   /* 33222222222211111111110000000000
2054                                                                      10987654321098765432109876543210
2055                                                                      1x111000101xxxxx000100xxxxxxxxxx
2056                                                                      ldclra.  */
2057                                                                   return 1063;
2058                                                                 }
2059                                                             }
2060                                                         }
2061                                                       else
2062                                                         {
2063                                                           if (((word >> 23) & 0x1) == 0)
2064                                                             {
2065                                                               if (((word >> 31) & 0x1) == 0)
2066                                                                 {
2067                                                                   if (((word >> 30) & 0x1) == 0)
2068                                                                     {
2069                                                                       /* 33222222222211111111110000000000
2070                                                                          10987654321098765432109876543210
2071                                                                          00111000011xxxxx000100xxxxxxxxxx
2072                                                                          ldclrlb.  */
2073                                                                       return 1058;
2074                                                                     }
2075                                                                   else
2076                                                                     {
2077                                                                       /* 33222222222211111111110000000000
2078                                                                          10987654321098765432109876543210
2079                                                                          01111000011xxxxx000100xxxxxxxxxx
2080                                                                          ldclrlh.  */
2081                                                                       return 1061;
2082                                                                     }
2083                                                                 }
2084                                                               else
2085                                                                 {
2086                                                                   /* 33222222222211111111110000000000
2087                                                                      10987654321098765432109876543210
2088                                                                      1x111000011xxxxx000100xxxxxxxxxx
2089                                                                      ldclrl.  */
2090                                                                   return 1064;
2091                                                                 }
2092                                                             }
2093                                                           else
2094                                                             {
2095                                                               if (((word >> 31) & 0x1) == 0)
2096                                                                 {
2097                                                                   if (((word >> 30) & 0x1) == 0)
2098                                                                     {
2099                                                                       /* 33222222222211111111110000000000
2100                                                                          10987654321098765432109876543210
2101                                                                          00111000111xxxxx000100xxxxxxxxxx
2102                                                                          ldclralb.  */
2103                                                                       return 1059;
2104                                                                     }
2105                                                                   else
2106                                                                     {
2107                                                                       /* 33222222222211111111110000000000
2108                                                                          10987654321098765432109876543210
2109                                                                          01111000111xxxxx000100xxxxxxxxxx
2110                                                                          ldclralh.  */
2111                                                                       return 1062;
2112                                                                     }
2113                                                                 }
2114                                                               else
2115                                                                 {
2116                                                                   /* 33222222222211111111110000000000
2117                                                                      10987654321098765432109876543210
2118                                                                      1x111000111xxxxx000100xxxxxxxxxx
2119                                                                      ldclral.  */
2120                                                                   return 1065;
2121                                                                 }
2122                                                             }
2123                                                         }
2124                                                     }
2125                                                   else
2126                                                     {
2127                                                       /* 33222222222211111111110000000000
2128                                                          10987654321098765432109876543210
2129                                                          xx111000xx1xxxxx100100xxxxxxxxxx
2130                                                          st64b.  */
2131                                                       return 992;
2132                                                     }
2133                                                 }
2134                                               else
2135                                                 {
2136                                                   if (((word >> 15) & 0x1) == 0)
2137                                                     {
2138                                                       if (((word >> 22) & 0x1) == 0)
2139                                                         {
2140                                                           if (((word >> 23) & 0x1) == 0)
2141                                                             {
2142                                                               if (((word >> 31) & 0x1) == 0)
2143                                                                 {
2144                                                                   if (((word >> 30) & 0x1) == 0)
2145                                                                     {
2146                                                                       /* 33222222222211111111110000000000
2147                                                                          10987654321098765432109876543210
2148                                                                          00111000001xxxxx010100xxxxxxxxxx
2149                                                                          ldsminb.  */
2150                                                                       return 1102;
2151                                                                     }
2152                                                                   else
2153                                                                     {
2154                                                                       /* 33222222222211111111110000000000
2155                                                                          10987654321098765432109876543210
2156                                                                          01111000001xxxxx010100xxxxxxxxxx
2157                                                                          ldsminh.  */
2158                                                                       return 1103;
2159                                                                     }
2160                                                                 }
2161                                                               else
2162                                                                 {
2163                                                                   /* 33222222222211111111110000000000
2164                                                                      10987654321098765432109876543210
2165                                                                      1x111000001xxxxx010100xxxxxxxxxx
2166                                                                      ldsmin.  */
2167                                                                   return 1104;
2168                                                                 }
2169                                                             }
2170                                                           else
2171                                                             {
2172                                                               if (((word >> 31) & 0x1) == 0)
2173                                                                 {
2174                                                                   if (((word >> 30) & 0x1) == 0)
2175                                                                     {
2176                                                                       /* 33222222222211111111110000000000
2177                                                                          10987654321098765432109876543210
2178                                                                          00111000101xxxxx010100xxxxxxxxxx
2179                                                                          ldsminab.  */
2180                                                                       return 1105;
2181                                                                     }
2182                                                                   else
2183                                                                     {
2184                                                                       /* 33222222222211111111110000000000
2185                                                                          10987654321098765432109876543210
2186                                                                          01111000101xxxxx010100xxxxxxxxxx
2187                                                                          ldsminah.  */
2188                                                                       return 1108;
2189                                                                     }
2190                                                                 }
2191                                                               else
2192                                                                 {
2193                                                                   /* 33222222222211111111110000000000
2194                                                                      10987654321098765432109876543210
2195                                                                      1x111000101xxxxx010100xxxxxxxxxx
2196                                                                      ldsmina.  */
2197                                                                   return 1111;
2198                                                                 }
2199                                                             }
2200                                                         }
2201                                                       else
2202                                                         {
2203                                                           if (((word >> 23) & 0x1) == 0)
2204                                                             {
2205                                                               if (((word >> 31) & 0x1) == 0)
2206                                                                 {
2207                                                                   if (((word >> 30) & 0x1) == 0)
2208                                                                     {
2209                                                                       /* 33222222222211111111110000000000
2210                                                                          10987654321098765432109876543210
2211                                                                          00111000011xxxxx010100xxxxxxxxxx
2212                                                                          ldsminlb.  */
2213                                                                       return 1106;
2214                                                                     }
2215                                                                   else
2216                                                                     {
2217                                                                       /* 33222222222211111111110000000000
2218                                                                          10987654321098765432109876543210
2219                                                                          01111000011xxxxx010100xxxxxxxxxx
2220                                                                          ldsminlh.  */
2221                                                                       return 1109;
2222                                                                     }
2223                                                                 }
2224                                                               else
2225                                                                 {
2226                                                                   /* 33222222222211111111110000000000
2227                                                                      10987654321098765432109876543210
2228                                                                      1x111000011xxxxx010100xxxxxxxxxx
2229                                                                      ldsminl.  */
2230                                                                   return 1112;
2231                                                                 }
2232                                                             }
2233                                                           else
2234                                                             {
2235                                                               if (((word >> 31) & 0x1) == 0)
2236                                                                 {
2237                                                                   if (((word >> 30) & 0x1) == 0)
2238                                                                     {
2239                                                                       /* 33222222222211111111110000000000
2240                                                                          10987654321098765432109876543210
2241                                                                          00111000111xxxxx010100xxxxxxxxxx
2242                                                                          ldsminalb.  */
2243                                                                       return 1107;
2244                                                                     }
2245                                                                   else
2246                                                                     {
2247                                                                       /* 33222222222211111111110000000000
2248                                                                          10987654321098765432109876543210
2249                                                                          01111000111xxxxx010100xxxxxxxxxx
2250                                                                          ldsminalh.  */
2251                                                                       return 1110;
2252                                                                     }
2253                                                                 }
2254                                                               else
2255                                                                 {
2256                                                                   /* 33222222222211111111110000000000
2257                                                                      10987654321098765432109876543210
2258                                                                      1x111000111xxxxx010100xxxxxxxxxx
2259                                                                      ldsminal.  */
2260                                                                   return 1113;
2261                                                                 }
2262                                                             }
2263                                                         }
2264                                                     }
2265                                                   else
2266                                                     {
2267                                                       /* 33222222222211111111110000000000
2268                                                          10987654321098765432109876543210
2269                                                          xx111000xx1xxxxx110100xxxxxxxxxx
2270                                                          ld64b.  */
2271                                                       return 991;
2272                                                     }
2273                                                 }
2274                                             }
2275                                           else
2276                                             {
2277                                               if (((word >> 14) & 0x1) == 0)
2278                                                 {
2279                                                   if (((word >> 15) & 0x1) == 0)
2280                                                     {
2281                                                       if (((word >> 22) & 0x1) == 0)
2282                                                         {
2283                                                           if (((word >> 23) & 0x1) == 0)
2284                                                             {
2285                                                               if (((word >> 31) & 0x1) == 0)
2286                                                                 {
2287                                                                   if (((word >> 30) & 0x1) == 0)
2288                                                                     {
2289                                                                       /* 33222222222211111111110000000000
2290                                                                          10987654321098765432109876543210
2291                                                                          00111000001xxxxx001100xxxxxxxxxx
2292                                                                          ldsetb.  */
2293                                                                       return 1078;
2294                                                                     }
2295                                                                   else
2296                                                                     {
2297                                                                       /* 33222222222211111111110000000000
2298                                                                          10987654321098765432109876543210
2299                                                                          01111000001xxxxx001100xxxxxxxxxx
2300                                                                          ldseth.  */
2301                                                                       return 1079;
2302                                                                     }
2303                                                                 }
2304                                                               else
2305                                                                 {
2306                                                                   /* 33222222222211111111110000000000
2307                                                                      10987654321098765432109876543210
2308                                                                      1x111000001xxxxx001100xxxxxxxxxx
2309                                                                      ldset.  */
2310                                                                   return 1080;
2311                                                                 }
2312                                                             }
2313                                                           else
2314                                                             {
2315                                                               if (((word >> 31) & 0x1) == 0)
2316                                                                 {
2317                                                                   if (((word >> 30) & 0x1) == 0)
2318                                                                     {
2319                                                                       /* 33222222222211111111110000000000
2320                                                                          10987654321098765432109876543210
2321                                                                          00111000101xxxxx001100xxxxxxxxxx
2322                                                                          ldsetab.  */
2323                                                                       return 1081;
2324                                                                     }
2325                                                                   else
2326                                                                     {
2327                                                                       /* 33222222222211111111110000000000
2328                                                                          10987654321098765432109876543210
2329                                                                          01111000101xxxxx001100xxxxxxxxxx
2330                                                                          ldsetah.  */
2331                                                                       return 1084;
2332                                                                     }
2333                                                                 }
2334                                                               else
2335                                                                 {
2336                                                                   /* 33222222222211111111110000000000
2337                                                                      10987654321098765432109876543210
2338                                                                      1x111000101xxxxx001100xxxxxxxxxx
2339                                                                      ldseta.  */
2340                                                                   return 1087;
2341                                                                 }
2342                                                             }
2343                                                         }
2344                                                       else
2345                                                         {
2346                                                           if (((word >> 23) & 0x1) == 0)
2347                                                             {
2348                                                               if (((word >> 31) & 0x1) == 0)
2349                                                                 {
2350                                                                   if (((word >> 30) & 0x1) == 0)
2351                                                                     {
2352                                                                       /* 33222222222211111111110000000000
2353                                                                          10987654321098765432109876543210
2354                                                                          00111000011xxxxx001100xxxxxxxxxx
2355                                                                          ldsetlb.  */
2356                                                                       return 1082;
2357                                                                     }
2358                                                                   else
2359                                                                     {
2360                                                                       /* 33222222222211111111110000000000
2361                                                                          10987654321098765432109876543210
2362                                                                          01111000011xxxxx001100xxxxxxxxxx
2363                                                                          ldsetlh.  */
2364                                                                       return 1085;
2365                                                                     }
2366                                                                 }
2367                                                               else
2368                                                                 {
2369                                                                   /* 33222222222211111111110000000000
2370                                                                      10987654321098765432109876543210
2371                                                                      1x111000011xxxxx001100xxxxxxxxxx
2372                                                                      ldsetl.  */
2373                                                                   return 1088;
2374                                                                 }
2375                                                             }
2376                                                           else
2377                                                             {
2378                                                               if (((word >> 31) & 0x1) == 0)
2379                                                                 {
2380                                                                   if (((word >> 30) & 0x1) == 0)
2381                                                                     {
2382                                                                       /* 33222222222211111111110000000000
2383                                                                          10987654321098765432109876543210
2384                                                                          00111000111xxxxx001100xxxxxxxxxx
2385                                                                          ldsetalb.  */
2386                                                                       return 1083;
2387                                                                     }
2388                                                                   else
2389                                                                     {
2390                                                                       /* 33222222222211111111110000000000
2391                                                                          10987654321098765432109876543210
2392                                                                          01111000111xxxxx001100xxxxxxxxxx
2393                                                                          ldsetalh.  */
2394                                                                       return 1086;
2395                                                                     }
2396                                                                 }
2397                                                               else
2398                                                                 {
2399                                                                   /* 33222222222211111111110000000000
2400                                                                      10987654321098765432109876543210
2401                                                                      1x111000111xxxxx001100xxxxxxxxxx
2402                                                                      ldsetal.  */
2403                                                                   return 1089;
2404                                                                 }
2405                                                             }
2406                                                         }
2407                                                     }
2408                                                   else
2409                                                     {
2410                                                       /* 33222222222211111111110000000000
2411                                                          10987654321098765432109876543210
2412                                                          xx111000xx1xxxxx101100xxxxxxxxxx
2413                                                          st64bv.  */
2414                                                       return 993;
2415                                                     }
2416                                                 }
2417                                               else
2418                                                 {
2419                                                   if (((word >> 22) & 0x1) == 0)
2420                                                     {
2421                                                       if (((word >> 23) & 0x1) == 0)
2422                                                         {
2423                                                           if (((word >> 31) & 0x1) == 0)
2424                                                             {
2425                                                               if (((word >> 30) & 0x1) == 0)
2426                                                                 {
2427                                                                   /* 33222222222211111111110000000000
2428                                                                      10987654321098765432109876543210
2429                                                                      00111000001xxxxxx11100xxxxxxxxxx
2430                                                                      lduminb.  */
2431                                                                   return 1126;
2432                                                                 }
2433                                                               else
2434                                                                 {
2435                                                                   /* 33222222222211111111110000000000
2436                                                                      10987654321098765432109876543210
2437                                                                      01111000001xxxxxx11100xxxxxxxxxx
2438                                                                      lduminh.  */
2439                                                                   return 1127;
2440                                                                 }
2441                                                             }
2442                                                           else
2443                                                             {
2444                                                               /* 33222222222211111111110000000000
2445                                                                  10987654321098765432109876543210
2446                                                                  1x111000001xxxxxx11100xxxxxxxxxx
2447                                                                  ldumin.  */
2448                                                               return 1128;
2449                                                             }
2450                                                         }
2451                                                       else
2452                                                         {
2453                                                           if (((word >> 31) & 0x1) == 0)
2454                                                             {
2455                                                               if (((word >> 30) & 0x1) == 0)
2456                                                                 {
2457                                                                   /* 33222222222211111111110000000000
2458                                                                      10987654321098765432109876543210
2459                                                                      00111000101xxxxxx11100xxxxxxxxxx
2460                                                                      lduminab.  */
2461                                                                   return 1129;
2462                                                                 }
2463                                                               else
2464                                                                 {
2465                                                                   /* 33222222222211111111110000000000
2466                                                                      10987654321098765432109876543210
2467                                                                      01111000101xxxxxx11100xxxxxxxxxx
2468                                                                      lduminah.  */
2469                                                                   return 1132;
2470                                                                 }
2471                                                             }
2472                                                           else
2473                                                             {
2474                                                               /* 33222222222211111111110000000000
2475                                                                  10987654321098765432109876543210
2476                                                                  1x111000101xxxxxx11100xxxxxxxxxx
2477                                                                  ldumina.  */
2478                                                               return 1135;
2479                                                             }
2480                                                         }
2481                                                     }
2482                                                   else
2483                                                     {
2484                                                       if (((word >> 23) & 0x1) == 0)
2485                                                         {
2486                                                           if (((word >> 31) & 0x1) == 0)
2487                                                             {
2488                                                               if (((word >> 30) & 0x1) == 0)
2489                                                                 {
2490                                                                   /* 33222222222211111111110000000000
2491                                                                      10987654321098765432109876543210
2492                                                                      00111000011xxxxxx11100xxxxxxxxxx
2493                                                                      lduminlb.  */
2494                                                                   return 1130;
2495                                                                 }
2496                                                               else
2497                                                                 {
2498                                                                   /* 33222222222211111111110000000000
2499                                                                      10987654321098765432109876543210
2500                                                                      01111000011xxxxxx11100xxxxxxxxxx
2501                                                                      lduminlh.  */
2502                                                                   return 1133;
2503                                                                 }
2504                                                             }
2505                                                           else
2506                                                             {
2507                                                               /* 33222222222211111111110000000000
2508                                                                  10987654321098765432109876543210
2509                                                                  1x111000011xxxxxx11100xxxxxxxxxx
2510                                                                  lduminl.  */
2511                                                               return 1136;
2512                                                             }
2513                                                         }
2514                                                       else
2515                                                         {
2516                                                           if (((word >> 31) & 0x1) == 0)
2517                                                             {
2518                                                               if (((word >> 30) & 0x1) == 0)
2519                                                                 {
2520                                                                   /* 33222222222211111111110000000000
2521                                                                      10987654321098765432109876543210
2522                                                                      00111000111xxxxxx11100xxxxxxxxxx
2523                                                                      lduminalb.  */
2524                                                                   return 1131;
2525                                                                 }
2526                                                               else
2527                                                                 {
2528                                                                   /* 33222222222211111111110000000000
2529                                                                      10987654321098765432109876543210
2530                                                                      01111000111xxxxxx11100xxxxxxxxxx
2531                                                                      lduminalh.  */
2532                                                                   return 1134;
2533                                                                 }
2534                                                             }
2535                                                           else
2536                                                             {
2537                                                               /* 33222222222211111111110000000000
2538                                                                  10987654321098765432109876543210
2539                                                                  1x111000111xxxxxx11100xxxxxxxxxx
2540                                                                  lduminal.  */
2541                                                               return 1137;
2542                                                             }
2543                                                         }
2544                                                     }
2545                                                 }
2546                                             }
2547                                         }
2548                                     }
2549                                 }
2550                               else
2551                                 {
2552                                   if (((word >> 21) & 0x1) == 0)
2553                                     {
2554                                       if (((word >> 23) & 0x1) == 0)
2555                                         {
2556                                           if (((word >> 22) & 0x1) == 0)
2557                                             {
2558                                               if (((word >> 31) & 0x1) == 0)
2559                                                 {
2560                                                   if (((word >> 30) & 0x1) == 0)
2561                                                     {
2562                                                       /* 33222222222211111111110000000000
2563                                                          10987654321098765432109876543210
2564                                                          00111000000xxxxxxxxx10xxxxxxxxxx
2565                                                          sttrb.  */
2566                                                       return 913;
2567                                                     }
2568                                                   else
2569                                                     {
2570                                                       /* 33222222222211111111110000000000
2571                                                          10987654321098765432109876543210
2572                                                          01111000000xxxxxxxxx10xxxxxxxxxx
2573                                                          sttrh.  */
2574                                                       return 916;
2575                                                     }
2576                                                 }
2577                                               else
2578                                                 {
2579                                                   /* 33222222222211111111110000000000
2580                                                      10987654321098765432109876543210
2581                                                      1x111000000xxxxxxxxx10xxxxxxxxxx
2582                                                      sttr.  */
2583                                                   return 919;
2584                                                 }
2585                                             }
2586                                           else
2587                                             {
2588                                               if (((word >> 31) & 0x1) == 0)
2589                                                 {
2590                                                   if (((word >> 30) & 0x1) == 0)
2591                                                     {
2592                                                       /* 33222222222211111111110000000000
2593                                                          10987654321098765432109876543210
2594                                                          00111000010xxxxxxxxx10xxxxxxxxxx
2595                                                          ldtrb.  */
2596                                                       return 914;
2597                                                     }
2598                                                   else
2599                                                     {
2600                                                       /* 33222222222211111111110000000000
2601                                                          10987654321098765432109876543210
2602                                                          01111000010xxxxxxxxx10xxxxxxxxxx
2603                                                          ldtrh.  */
2604                                                       return 917;
2605                                                     }
2606                                                 }
2607                                               else
2608                                                 {
2609                                                   /* 33222222222211111111110000000000
2610                                                      10987654321098765432109876543210
2611                                                      1x111000010xxxxxxxxx10xxxxxxxxxx
2612                                                      ldtr.  */
2613                                                   return 920;
2614                                                 }
2615                                             }
2616                                         }
2617                                       else
2618                                         {
2619                                           if (((word >> 30) & 0x1) == 0)
2620                                             {
2621                                               if (((word >> 31) & 0x1) == 0)
2622                                                 {
2623                                                   /* 33222222222211111111110000000000
2624                                                      10987654321098765432109876543210
2625                                                      001110001x0xxxxxxxxx10xxxxxxxxxx
2626                                                      ldtrsb.  */
2627                                                   return 915;
2628                                                 }
2629                                               else
2630                                                 {
2631                                                   /* 33222222222211111111110000000000
2632                                                      10987654321098765432109876543210
2633                                                      101110001x0xxxxxxxxx10xxxxxxxxxx
2634                                                      ldtrsw.  */
2635                                                   return 921;
2636                                                 }
2637                                             }
2638                                           else
2639                                             {
2640                                               /* 33222222222211111111110000000000
2641                                                  10987654321098765432109876543210
2642                                                  x11110001x0xxxxxxxxx10xxxxxxxxxx
2643                                                  ldtrsh.  */
2644                                               return 918;
2645                                             }
2646                                         }
2647                                     }
2648                                   else
2649                                     {
2650                                       if (((word >> 23) & 0x1) == 0)
2651                                         {
2652                                           if (((word >> 22) & 0x1) == 0)
2653                                             {
2654                                               if (((word >> 31) & 0x1) == 0)
2655                                                 {
2656                                                   if (((word >> 30) & 0x1) == 0)
2657                                                     {
2658                                                       /* 33222222222211111111110000000000
2659                                                          10987654321098765432109876543210
2660                                                          00111000001xxxxxxxxx10xxxxxxxxxx
2661                                                          strb.  */
2662                                                       return 901;
2663                                                     }
2664                                                   else
2665                                                     {
2666                                                       /* 33222222222211111111110000000000
2667                                                          10987654321098765432109876543210
2668                                                          01111000001xxxxxxxxx10xxxxxxxxxx
2669                                                          strh.  */
2670                                                       return 906;
2671                                                     }
2672                                                 }
2673                                               else
2674                                                 {
2675                                                   /* 33222222222211111111110000000000
2676                                                      10987654321098765432109876543210
2677                                                      1x111000001xxxxxxxxx10xxxxxxxxxx
2678                                                      str.  */
2679                                                   return 909;
2680                                                 }
2681                                             }
2682                                           else
2683                                             {
2684                                               if (((word >> 31) & 0x1) == 0)
2685                                                 {
2686                                                   if (((word >> 30) & 0x1) == 0)
2687                                                     {
2688                                                       /* 33222222222211111111110000000000
2689                                                          10987654321098765432109876543210
2690                                                          00111000011xxxxxxxxx10xxxxxxxxxx
2691                                                          ldrb.  */
2692                                                       return 902;
2693                                                     }
2694                                                   else
2695                                                     {
2696                                                       /* 33222222222211111111110000000000
2697                                                          10987654321098765432109876543210
2698                                                          01111000011xxxxxxxxx10xxxxxxxxxx
2699                                                          ldrh.  */
2700                                                       return 907;
2701                                                     }
2702                                                 }
2703                                               else
2704                                                 {
2705                                                   /* 33222222222211111111110000000000
2706                                                      10987654321098765432109876543210
2707                                                      1x111000011xxxxxxxxx10xxxxxxxxxx
2708                                                      ldr.  */
2709                                                   return 910;
2710                                                 }
2711                                             }
2712                                         }
2713                                       else
2714                                         {
2715                                           if (((word >> 30) & 0x1) == 0)
2716                                             {
2717                                               if (((word >> 31) & 0x1) == 0)
2718                                                 {
2719                                                   /* 33222222222211111111110000000000
2720                                                      10987654321098765432109876543210
2721                                                      001110001x1xxxxxxxxx10xxxxxxxxxx
2722                                                      ldrsb.  */
2723                                                   return 903;
2724                                                 }
2725                                               else
2726                                                 {
2727                                                   /* 33222222222211111111110000000000
2728                                                      10987654321098765432109876543210
2729                                                      101110001x1xxxxxxxxx10xxxxxxxxxx
2730                                                      ldrsw.  */
2731                                                   return 911;
2732                                                 }
2733                                             }
2734                                           else
2735                                             {
2736                                               if (((word >> 31) & 0x1) == 0)
2737                                                 {
2738                                                   /* 33222222222211111111110000000000
2739                                                      10987654321098765432109876543210
2740                                                      011110001x1xxxxxxxxx10xxxxxxxxxx
2741                                                      ldrsh.  */
2742                                                   return 908;
2743                                                 }
2744                                               else
2745                                                 {
2746                                                   /* 33222222222211111111110000000000
2747                                                      10987654321098765432109876543210
2748                                                      111110001x1xxxxxxxxx10xxxxxxxxxx
2749                                                      prfm.  */
2750                                                   return 912;
2751                                                 }
2752                                             }
2753                                         }
2754                                     }
2755                                 }
2756                             }
2757                           else
2758                             {
2759                               if (((word >> 21) & 0x1) == 0)
2760                                 {
2761                                   if (((word >> 23) & 0x1) == 0)
2762                                     {
2763                                       if (((word >> 22) & 0x1) == 0)
2764                                         {
2765                                           if (((word >> 31) & 0x1) == 0)
2766                                             {
2767                                               if (((word >> 30) & 0x1) == 0)
2768                                                 {
2769                                                   /* 33222222222211111111110000000000
2770                                                      10987654321098765432109876543210
2771                                                      00111000000xxxxxxxxxx1xxxxxxxxxx
2772                                                      strb.  */
2773                                                   return 870;
2774                                                 }
2775                                               else
2776                                                 {
2777                                                   /* 33222222222211111111110000000000
2778                                                      10987654321098765432109876543210
2779                                                      01111000000xxxxxxxxxx1xxxxxxxxxx
2780                                                      strh.  */
2781                                                   return 875;
2782                                                 }
2783                                             }
2784                                           else
2785                                             {
2786                                               /* 33222222222211111111110000000000
2787                                                  10987654321098765432109876543210
2788                                                  1x111000000xxxxxxxxxx1xxxxxxxxxx
2789                                                  str.  */
2790                                               return 878;
2791                                             }
2792                                         }
2793                                       else
2794                                         {
2795                                           if (((word >> 31) & 0x1) == 0)
2796                                             {
2797                                               if (((word >> 30) & 0x1) == 0)
2798                                                 {
2799                                                   /* 33222222222211111111110000000000
2800                                                      10987654321098765432109876543210
2801                                                      00111000010xxxxxxxxxx1xxxxxxxxxx
2802                                                      ldrb.  */
2803                                                   return 871;
2804                                                 }
2805                                               else
2806                                                 {
2807                                                   /* 33222222222211111111110000000000
2808                                                      10987654321098765432109876543210
2809                                                      01111000010xxxxxxxxxx1xxxxxxxxxx
2810                                                      ldrh.  */
2811                                                   return 876;
2812                                                 }
2813                                             }
2814                                           else
2815                                             {
2816                                               /* 33222222222211111111110000000000
2817                                                  10987654321098765432109876543210
2818                                                  1x111000010xxxxxxxxxx1xxxxxxxxxx
2819                                                  ldr.  */
2820                                               return 879;
2821                                             }
2822                                         }
2823                                     }
2824                                   else
2825                                     {
2826                                       if (((word >> 30) & 0x1) == 0)
2827                                         {
2828                                           if (((word >> 31) & 0x1) == 0)
2829                                             {
2830                                               /* 33222222222211111111110000000000
2831                                                  10987654321098765432109876543210
2832                                                  001110001x0xxxxxxxxxx1xxxxxxxxxx
2833                                                  ldrsb.  */
2834                                               return 872;
2835                                             }
2836                                           else
2837                                             {
2838                                               /* 33222222222211111111110000000000
2839                                                  10987654321098765432109876543210
2840                                                  101110001x0xxxxxxxxxx1xxxxxxxxxx
2841                                                  ldrsw.  */
2842                                               return 880;
2843                                             }
2844                                         }
2845                                       else
2846                                         {
2847                                           /* 33222222222211111111110000000000
2848                                              10987654321098765432109876543210
2849                                              x11110001x0xxxxxxxxxx1xxxxxxxxxx
2850                                              ldrsh.  */
2851                                           return 877;
2852                                         }
2853                                     }
2854                                 }
2855                               else
2856                                 {
2857                                   if (((word >> 23) & 0x1) == 0)
2858                                     {
2859                                       /* 33222222222211111111110000000000
2860                                          10987654321098765432109876543210
2861                                          xx1110000x1xxxxxxxxxx1xxxxxxxxxx
2862                                          ldraa.  */
2863                                       return 935;
2864                                     }
2865                                   else
2866                                     {
2867                                       /* 33222222222211111111110000000000
2868                                          10987654321098765432109876543210
2869                                          xx1110001x1xxxxxxxxxx1xxxxxxxxxx
2870                                          ldrab.  */
2871                                       return 936;
2872                                     }
2873                                 }
2874                             }
2875                         }
2876                     }
2877                   else
2878                     {
2879                       if (((word >> 23) & 0x1) == 0)
2880                         {
2881                           if (((word >> 22) & 0x1) == 0)
2882                             {
2883                               if (((word >> 29) & 0x1) == 0)
2884                                 {
2885                                   if (((word >> 10) & 0x1) == 0)
2886                                     {
2887                                       if (((word >> 11) & 0x1) == 0)
2888                                         {
2889                                           if (((word >> 21) & 0x1) == 0)
2890                                             {
2891                                               if (((word >> 30) & 0x1) == 0)
2892                                                 {
2893                                                   if (((word >> 31) & 0x1) == 0)
2894                                                     {
2895                                                       /* 33222222222211111111110000000000
2896                                                          10987654321098765432109876543210
2897                                                          00011001000xxxxxxxxx00xxxxxxxxxx
2898                                                          stlurb.  */
2899                                                       return 2455;
2900                                                     }
2901                                                   else
2902                                                     {
2903                                                       /* 33222222222211111111110000000000
2904                                                          10987654321098765432109876543210
2905                                                          10011001000xxxxxxxxx00xxxxxxxxxx
2906                                                          stlur.  */
2907                                                       return 2463;
2908                                                     }
2909                                                 }
2910                                               else
2911                                                 {
2912                                                   if (((word >> 31) & 0x1) == 0)
2913                                                     {
2914                                                       /* 33222222222211111111110000000000
2915                                                          10987654321098765432109876543210
2916                                                          01011001000xxxxxxxxx00xxxxxxxxxx
2917                                                          stlurh.  */
2918                                                       return 2459;
2919                                                     }
2920                                                   else
2921                                                     {
2922                                                       /* 33222222222211111111110000000000
2923                                                          10987654321098765432109876543210
2924                                                          11011001000xxxxxxxxx00xxxxxxxxxx
2925                                                          stlur.  */
2926                                                       return 2466;
2927                                                     }
2928                                                 }
2929                                             }
2930                                           else
2931                                             {
2932                                               /* 33222222222211111111110000000000
2933                                                  10987654321098765432109876543210
2934                                                  xx011001001xxxxxxxxx00xxxxxxxxxx
2935                                                  stzgm.  */
2936                                               return 964;
2937                                             }
2938                                         }
2939                                       else
2940                                         {
2941                                           /* 33222222222211111111110000000000
2942                                              10987654321098765432109876543210
2943                                              xx01100100xxxxxxxxxx10xxxxxxxxxx
2944                                              stg.  */
2945                                           return 881;
2946                                         }
2947                                     }
2948                                   else
2949                                     {
2950                                       if (((word >> 21) & 0x1) == 0)
2951                                         {
2952                                           if (((word >> 12) & 0x1) == 0)
2953                                             {
2954                                               if (((word >> 13) & 0x1) == 0)
2955                                                 {
2956                                                   if (((word >> 14) & 0x1) == 0)
2957                                                     {
2958                                                       if (((word >> 15) & 0x1) == 0)
2959                                                         {
2960                                                           /* 33222222222211111111110000000000
2961                                                              10987654321098765432109876543210
2962                                                              xx011001000xxxxx0000x1xxxxxxxxxx
2963                                                              cpyfp.  */
2964                                                           return 2515;
2965                                                         }
2966                                                       else
2967                                                         {
2968                                                           /* 33222222222211111111110000000000
2969                                                              10987654321098765432109876543210
2970                                                              xx011001000xxxxx1000x1xxxxxxxxxx
2971                                                              cpyfprn.  */
2972                                                           return 2521;
2973                                                         }
2974                                                     }
2975                                                   else
2976                                                     {
2977                                                       if (((word >> 15) & 0x1) == 0)
2978                                                         {
2979                                                           /* 33222222222211111111110000000000
2980                                                              10987654321098765432109876543210
2981                                                              xx011001000xxxxx0100x1xxxxxxxxxx
2982                                                              cpyfpwn.  */
2983                                                           return 2518;
2984                                                         }
2985                                                       else
2986                                                         {
2987                                                           /* 33222222222211111111110000000000
2988                                                              10987654321098765432109876543210
2989                                                              xx011001000xxxxx1100x1xxxxxxxxxx
2990                                                              cpyfpn.  */
2991                                                           return 2524;
2992                                                         }
2993                                                     }
2994                                                 }
2995                                               else
2996                                                 {
2997                                                   if (((word >> 14) & 0x1) == 0)
2998                                                     {
2999                                                       if (((word >> 15) & 0x1) == 0)
3000                                                         {
3001                                                           /* 33222222222211111111110000000000
3002                                                              10987654321098765432109876543210
3003                                                              xx011001000xxxxx0010x1xxxxxxxxxx
3004                                                              cpyfprt.  */
3005                                                           return 2539;
3006                                                         }
3007                                                       else
3008                                                         {
3009                                                           /* 33222222222211111111110000000000
3010                                                              10987654321098765432109876543210
3011                                                              xx011001000xxxxx1010x1xxxxxxxxxx
3012                                                              cpyfprtrn.  */
3013                                                           return 2545;
3014                                                         }
3015                                                     }
3016                                                   else
3017                                                     {
3018                                                       if (((word >> 15) & 0x1) == 0)
3019                                                         {
3020                                                           /* 33222222222211111111110000000000
3021                                                              10987654321098765432109876543210
3022                                                              xx011001000xxxxx0110x1xxxxxxxxxx
3023                                                              cpyfprtwn.  */
3024                                                           return 2542;
3025                                                         }
3026                                                       else
3027                                                         {
3028                                                           /* 33222222222211111111110000000000
3029                                                              10987654321098765432109876543210
3030                                                              xx011001000xxxxx1110x1xxxxxxxxxx
3031                                                              cpyfprtn.  */
3032                                                           return 2548;
3033                                                         }
3034                                                     }
3035                                                 }
3036                                             }
3037                                           else
3038                                             {
3039                                               if (((word >> 13) & 0x1) == 0)
3040                                                 {
3041                                                   if (((word >> 14) & 0x1) == 0)
3042                                                     {
3043                                                       if (((word >> 15) & 0x1) == 0)
3044                                                         {
3045                                                           /* 33222222222211111111110000000000
3046                                                              10987654321098765432109876543210
3047                                                              xx011001000xxxxx0001x1xxxxxxxxxx
3048                                                              cpyfpwt.  */
3049                                                           return 2527;
3050                                                         }
3051                                                       else
3052                                                         {
3053                                                           /* 33222222222211111111110000000000
3054                                                              10987654321098765432109876543210
3055                                                              xx011001000xxxxx1001x1xxxxxxxxxx
3056                                                              cpyfpwtrn.  */
3057                                                           return 2533;
3058                                                         }
3059                                                     }
3060                                                   else
3061                                                     {
3062                                                       if (((word >> 15) & 0x1) == 0)
3063                                                         {
3064                                                           /* 33222222222211111111110000000000
3065                                                              10987654321098765432109876543210
3066                                                              xx011001000xxxxx0101x1xxxxxxxxxx
3067                                                              cpyfpwtwn.  */
3068                                                           return 2530;
3069                                                         }
3070                                                       else
3071                                                         {
3072                                                           /* 33222222222211111111110000000000
3073                                                              10987654321098765432109876543210
3074                                                              xx011001000xxxxx1101x1xxxxxxxxxx
3075                                                              cpyfpwtn.  */
3076                                                           return 2536;
3077                                                         }
3078                                                     }
3079                                                 }
3080                                               else
3081                                                 {
3082                                                   if (((word >> 14) & 0x1) == 0)
3083                                                     {
3084                                                       if (((word >> 15) & 0x1) == 0)
3085                                                         {
3086                                                           /* 33222222222211111111110000000000
3087                                                              10987654321098765432109876543210
3088                                                              xx011001000xxxxx0011x1xxxxxxxxxx
3089                                                              cpyfpt.  */
3090                                                           return 2551;
3091                                                         }
3092                                                       else
3093                                                         {
3094                                                           /* 33222222222211111111110000000000
3095                                                              10987654321098765432109876543210
3096                                                              xx011001000xxxxx1011x1xxxxxxxxxx
3097                                                              cpyfptrn.  */
3098                                                           return 2557;
3099                                                         }
3100                                                     }
3101                                                   else
3102                                                     {
3103                                                       if (((word >> 15) & 0x1) == 0)
3104                                                         {
3105                                                           /* 33222222222211111111110000000000
3106                                                              10987654321098765432109876543210
3107                                                              xx011001000xxxxx0111x1xxxxxxxxxx
3108                                                              cpyfptwn.  */
3109                                                           return 2554;
3110                                                         }
3111                                                       else
3112                                                         {
3113                                                           /* 33222222222211111111110000000000
3114                                                              10987654321098765432109876543210
3115                                                              xx011001000xxxxx1111x1xxxxxxxxxx
3116                                                              cpyfptn.  */
3117                                                           return 2560;
3118                                                         }
3119                                                     }
3120                                                 }
3121                                             }
3122                                         }
3123                                       else
3124                                         {
3125                                           /* 33222222222211111111110000000000
3126                                              10987654321098765432109876543210
3127                                              xx011001001xxxxxxxxxx1xxxxxxxxxx
3128                                              stg.  */
3129                                           return 885;
3130                                         }
3131                                     }
3132                                 }
3133                               else
3134                                 {
3135                                   if (((word >> 31) & 0x1) == 0)
3136                                     {
3137                                       if (((word >> 30) & 0x1) == 0)
3138                                         {
3139                                           /* 33222222222211111111110000000000
3140                                              10987654321098765432109876543210
3141                                              0011100100xxxxxxxxxxxxxxxxxxxxxx
3142                                              strb.  */
3143                                           return 889;
3144                                         }
3145                                       else
3146                                         {
3147                                           /* 33222222222211111111110000000000
3148                                              10987654321098765432109876543210
3149                                              0111100100xxxxxxxxxxxxxxxxxxxxxx
3150                                              strh.  */
3151                                           return 894;
3152                                         }
3153                                     }
3154                                   else
3155                                     {
3156                                       /* 33222222222211111111110000000000
3157                                          10987654321098765432109876543210
3158                                          1x11100100xxxxxxxxxxxxxxxxxxxxxx
3159                                          str.  */
3160                                       return 897;
3161                                     }
3162                                 }
3163                             }
3164                           else
3165                             {
3166                               if (((word >> 29) & 0x1) == 0)
3167                                 {
3168                                   if (((word >> 10) & 0x1) == 0)
3169                                     {
3170                                       if (((word >> 11) & 0x1) == 0)
3171                                         {
3172                                           if (((word >> 21) & 0x1) == 0)
3173                                             {
3174                                               if (((word >> 30) & 0x1) == 0)
3175                                                 {
3176                                                   if (((word >> 31) & 0x1) == 0)
3177                                                     {
3178                                                       /* 33222222222211111111110000000000
3179                                                          10987654321098765432109876543210
3180                                                          00011001010xxxxxxxxx00xxxxxxxxxx
3181                                                          ldapurb.  */
3182                                                       return 2456;
3183                                                     }
3184                                                   else
3185                                                     {
3186                                                       /* 33222222222211111111110000000000
3187                                                          10987654321098765432109876543210
3188                                                          10011001010xxxxxxxxx00xxxxxxxxxx
3189                                                          ldapur.  */
3190                                                       return 2464;
3191                                                     }
3192                                                 }
3193                                               else
3194                                                 {
3195                                                   if (((word >> 31) & 0x1) == 0)
3196                                                     {
3197                                                       /* 33222222222211111111110000000000
3198                                                          10987654321098765432109876543210
3199                                                          01011001010xxxxxxxxx00xxxxxxxxxx
3200                                                          ldapurh.  */
3201                                                       return 2460;
3202                                                     }
3203                                                   else
3204                                                     {
3205                                                       /* 33222222222211111111110000000000
3206                                                          10987654321098765432109876543210
3207                                                          11011001010xxxxxxxxx00xxxxxxxxxx
3208                                                          ldapur.  */
3209                                                       return 2467;
3210                                                     }
3211                                                 }
3212                                             }
3213                                           else
3214                                             {
3215                                               /* 33222222222211111111110000000000
3216                                                  10987654321098765432109876543210
3217                                                  xx011001011xxxxxxxxx00xxxxxxxxxx
3218                                                  ldg.  */
3219                                               return 934;
3220                                             }
3221                                         }
3222                                       else
3223                                         {
3224                                           /* 33222222222211111111110000000000
3225                                              10987654321098765432109876543210
3226                                              xx01100101xxxxxxxxxx10xxxxxxxxxx
3227                                              stzg.  */
3228                                           return 882;
3229                                         }
3230                                     }
3231                                   else
3232                                     {
3233                                       if (((word >> 21) & 0x1) == 0)
3234                                         {
3235                                           if (((word >> 12) & 0x1) == 0)
3236                                             {
3237                                               if (((word >> 13) & 0x1) == 0)
3238                                                 {
3239                                                   if (((word >> 14) & 0x1) == 0)
3240                                                     {
3241                                                       if (((word >> 15) & 0x1) == 0)
3242                                                         {
3243                                                           /* 33222222222211111111110000000000
3244                                                              10987654321098765432109876543210
3245                                                              xx011001010xxxxx0000x1xxxxxxxxxx
3246                                                              cpyfm.  */
3247                                                           return 2516;
3248                                                         }
3249                                                       else
3250                                                         {
3251                                                           /* 33222222222211111111110000000000
3252                                                              10987654321098765432109876543210
3253                                                              xx011001010xxxxx1000x1xxxxxxxxxx
3254                                                              cpyfmrn.  */
3255                                                           return 2522;
3256                                                         }
3257                                                     }
3258                                                   else
3259                                                     {
3260                                                       if (((word >> 15) & 0x1) == 0)
3261                                                         {
3262                                                           /* 33222222222211111111110000000000
3263                                                              10987654321098765432109876543210
3264                                                              xx011001010xxxxx0100x1xxxxxxxxxx
3265                                                              cpyfmwn.  */
3266                                                           return 2519;
3267                                                         }
3268                                                       else
3269                                                         {
3270                                                           /* 33222222222211111111110000000000
3271                                                              10987654321098765432109876543210
3272                                                              xx011001010xxxxx1100x1xxxxxxxxxx
3273                                                              cpyfmn.  */
3274                                                           return 2525;
3275                                                         }
3276                                                     }
3277                                                 }
3278                                               else
3279                                                 {
3280                                                   if (((word >> 14) & 0x1) == 0)
3281                                                     {
3282                                                       if (((word >> 15) & 0x1) == 0)
3283                                                         {
3284                                                           /* 33222222222211111111110000000000
3285                                                              10987654321098765432109876543210
3286                                                              xx011001010xxxxx0010x1xxxxxxxxxx
3287                                                              cpyfmrt.  */
3288                                                           return 2540;
3289                                                         }
3290                                                       else
3291                                                         {
3292                                                           /* 33222222222211111111110000000000
3293                                                              10987654321098765432109876543210
3294                                                              xx011001010xxxxx1010x1xxxxxxxxxx
3295                                                              cpyfmrtrn.  */
3296                                                           return 2546;
3297                                                         }
3298                                                     }
3299                                                   else
3300                                                     {
3301                                                       if (((word >> 15) & 0x1) == 0)
3302                                                         {
3303                                                           /* 33222222222211111111110000000000
3304                                                              10987654321098765432109876543210
3305                                                              xx011001010xxxxx0110x1xxxxxxxxxx
3306                                                              cpyfmrtwn.  */
3307                                                           return 2543;
3308                                                         }
3309                                                       else
3310                                                         {
3311                                                           /* 33222222222211111111110000000000
3312                                                              10987654321098765432109876543210
3313                                                              xx011001010xxxxx1110x1xxxxxxxxxx
3314                                                              cpyfmrtn.  */
3315                                                           return 2549;
3316                                                         }
3317                                                     }
3318                                                 }
3319                                             }
3320                                           else
3321                                             {
3322                                               if (((word >> 13) & 0x1) == 0)
3323                                                 {
3324                                                   if (((word >> 14) & 0x1) == 0)
3325                                                     {
3326                                                       if (((word >> 15) & 0x1) == 0)
3327                                                         {
3328                                                           /* 33222222222211111111110000000000
3329                                                              10987654321098765432109876543210
3330                                                              xx011001010xxxxx0001x1xxxxxxxxxx
3331                                                              cpyfmwt.  */
3332                                                           return 2528;
3333                                                         }
3334                                                       else
3335                                                         {
3336                                                           /* 33222222222211111111110000000000
3337                                                              10987654321098765432109876543210
3338                                                              xx011001010xxxxx1001x1xxxxxxxxxx
3339                                                              cpyfmwtrn.  */
3340                                                           return 2534;
3341                                                         }
3342                                                     }
3343                                                   else
3344                                                     {
3345                                                       if (((word >> 15) & 0x1) == 0)
3346                                                         {
3347                                                           /* 33222222222211111111110000000000
3348                                                              10987654321098765432109876543210
3349                                                              xx011001010xxxxx0101x1xxxxxxxxxx
3350                                                              cpyfmwtwn.  */
3351                                                           return 2531;
3352                                                         }
3353                                                       else
3354                                                         {
3355                                                           /* 33222222222211111111110000000000
3356                                                              10987654321098765432109876543210
3357                                                              xx011001010xxxxx1101x1xxxxxxxxxx
3358                                                              cpyfmwtn.  */
3359                                                           return 2537;
3360                                                         }
3361                                                     }
3362                                                 }
3363                                               else
3364                                                 {
3365                                                   if (((word >> 14) & 0x1) == 0)
3366                                                     {
3367                                                       if (((word >> 15) & 0x1) == 0)
3368                                                         {
3369                                                           /* 33222222222211111111110000000000
3370                                                              10987654321098765432109876543210
3371                                                              xx011001010xxxxx0011x1xxxxxxxxxx
3372                                                              cpyfmt.  */
3373                                                           return 2552;
3374                                                         }
3375                                                       else
3376                                                         {
3377                                                           /* 33222222222211111111110000000000
3378                                                              10987654321098765432109876543210
3379                                                              xx011001010xxxxx1011x1xxxxxxxxxx
3380                                                              cpyfmtrn.  */
3381                                                           return 2558;
3382                                                         }
3383                                                     }
3384                                                   else
3385                                                     {
3386                                                       if (((word >> 15) & 0x1) == 0)
3387                                                         {
3388                                                           /* 33222222222211111111110000000000
3389                                                              10987654321098765432109876543210
3390                                                              xx011001010xxxxx0111x1xxxxxxxxxx
3391                                                              cpyfmtwn.  */
3392                                                           return 2555;
3393                                                         }
3394                                                       else
3395                                                         {
3396                                                           /* 33222222222211111111110000000000
3397                                                              10987654321098765432109876543210
3398                                                              xx011001010xxxxx1111x1xxxxxxxxxx
3399                                                              cpyfmtn.  */
3400                                                           return 2561;
3401                                                         }
3402                                                     }
3403                                                 }
3404                                             }
3405                                         }
3406                                       else
3407                                         {
3408                                           /* 33222222222211111111110000000000
3409                                              10987654321098765432109876543210
3410                                              xx011001011xxxxxxxxxx1xxxxxxxxxx
3411                                              stzg.  */
3412                                           return 886;
3413                                         }
3414                                     }
3415                                 }
3416                               else
3417                                 {
3418                                   if (((word >> 31) & 0x1) == 0)
3419                                     {
3420                                       if (((word >> 30) & 0x1) == 0)
3421                                         {
3422                                           /* 33222222222211111111110000000000
3423                                              10987654321098765432109876543210
3424                                              0011100101xxxxxxxxxxxxxxxxxxxxxx
3425                                              ldrb.  */
3426                                           return 890;
3427                                         }
3428                                       else
3429                                         {
3430                                           /* 33222222222211111111110000000000
3431                                              10987654321098765432109876543210
3432                                              0111100101xxxxxxxxxxxxxxxxxxxxxx
3433                                              ldrh.  */
3434                                           return 895;
3435                                         }
3436                                     }
3437                                   else
3438                                     {
3439                                       /* 33222222222211111111110000000000
3440                                          10987654321098765432109876543210
3441                                          1x11100101xxxxxxxxxxxxxxxxxxxxxx
3442                                          ldr.  */
3443                                       return 898;
3444                                     }
3445                                 }
3446                             }
3447                         }
3448                       else
3449                         {
3450                           if (((word >> 29) & 0x1) == 0)
3451                             {
3452                               if (((word >> 10) & 0x1) == 0)
3453                                 {
3454                                   if (((word >> 11) & 0x1) == 0)
3455                                     {
3456                                       if (((word >> 21) & 0x1) == 0)
3457                                         {
3458                                           if (((word >> 22) & 0x1) == 0)
3459                                             {
3460                                               if (((word >> 30) & 0x1) == 0)
3461                                                 {
3462                                                   if (((word >> 31) & 0x1) == 0)
3463                                                     {
3464                                                       /* 33222222222211111111110000000000
3465                                                          10987654321098765432109876543210
3466                                                          00011001100xxxxxxxxx00xxxxxxxxxx
3467                                                          ldapursb.  */
3468                                                       return 2458;
3469                                                     }
3470                                                   else
3471                                                     {
3472                                                       /* 33222222222211111111110000000000
3473                                                          10987654321098765432109876543210
3474                                                          10011001100xxxxxxxxx00xxxxxxxxxx
3475                                                          ldapursw.  */
3476                                                       return 2465;
3477                                                     }
3478                                                 }
3479                                               else
3480                                                 {
3481                                                   /* 33222222222211111111110000000000
3482                                                      10987654321098765432109876543210
3483                                                      x1011001100xxxxxxxxx00xxxxxxxxxx
3484                                                      ldapursh.  */
3485                                                   return 2462;
3486                                                 }
3487                                             }
3488                                           else
3489                                             {
3490                                               if (((word >> 30) & 0x1) == 0)
3491                                                 {
3492                                                   /* 33222222222211111111110000000000
3493                                                      10987654321098765432109876543210
3494                                                      x0011001110xxxxxxxxx00xxxxxxxxxx
3495                                                      ldapursb.  */
3496                                                   return 2457;
3497                                                 }
3498                                               else
3499                                                 {
3500                                                   /* 33222222222211111111110000000000
3501                                                      10987654321098765432109876543210
3502                                                      x1011001110xxxxxxxxx00xxxxxxxxxx
3503                                                      ldapursh.  */
3504                                                   return 2461;
3505                                                 }
3506                                             }
3507                                         }
3508                                       else
3509                                         {
3510                                           if (((word >> 22) & 0x1) == 0)
3511                                             {
3512                                               /* 33222222222211111111110000000000
3513                                                  10987654321098765432109876543210
3514                                                  xx011001101xxxxxxxxx00xxxxxxxxxx
3515                                                  stgm.  */
3516                                               return 963;
3517                                             }
3518                                           else
3519                                             {
3520                                               /* 33222222222211111111110000000000
3521                                                  10987654321098765432109876543210
3522                                                  xx011001111xxxxxxxxx00xxxxxxxxxx
3523                                                  ldgm.  */
3524                                               return 962;
3525                                             }
3526                                         }
3527                                     }
3528                                   else
3529                                     {
3530                                       if (((word >> 22) & 0x1) == 0)
3531                                         {
3532                                           /* 33222222222211111111110000000000
3533                                              10987654321098765432109876543210
3534                                              xx01100110xxxxxxxxxx10xxxxxxxxxx
3535                                              st2g.  */
3536                                           return 883;
3537                                         }
3538                                       else
3539                                         {
3540                                           /* 33222222222211111111110000000000
3541                                              10987654321098765432109876543210
3542                                              xx01100111xxxxxxxxxx10xxxxxxxxxx
3543                                              stz2g.  */
3544                                           return 884;
3545                                         }
3546                                     }
3547                                 }
3548                               else
3549                                 {
3550                                   if (((word >> 21) & 0x1) == 0)
3551                                     {
3552                                       if (((word >> 12) & 0x1) == 0)
3553                                         {
3554                                           if (((word >> 13) & 0x1) == 0)
3555                                             {
3556                                               if (((word >> 14) & 0x1) == 0)
3557                                                 {
3558                                                   if (((word >> 15) & 0x1) == 0)
3559                                                     {
3560                                                       if (((word >> 22) & 0x1) == 0)
3561                                                         {
3562                                                           /* 33222222222211111111110000000000
3563                                                              10987654321098765432109876543210
3564                                                              xx011001100xxxxx0000x1xxxxxxxxxx
3565                                                              cpyfe.  */
3566                                                           return 2517;
3567                                                         }
3568                                                       else
3569                                                         {
3570                                                           /* 33222222222211111111110000000000
3571                                                              10987654321098765432109876543210
3572                                                              xx011001110xxxxx0000x1xxxxxxxxxx
3573                                                              setp.  */
3574                                                           return 2611;
3575                                                         }
3576                                                     }
3577                                                   else
3578                                                     {
3579                                                       if (((word >> 22) & 0x1) == 0)
3580                                                         {
3581                                                           /* 33222222222211111111110000000000
3582                                                              10987654321098765432109876543210
3583                                                              xx011001100xxxxx1000x1xxxxxxxxxx
3584                                                              cpyfern.  */
3585                                                           return 2523;
3586                                                         }
3587                                                       else
3588                                                         {
3589                                                           /* 33222222222211111111110000000000
3590                                                              10987654321098765432109876543210
3591                                                              xx011001110xxxxx1000x1xxxxxxxxxx
3592                                                              sete.  */
3593                                                           return 2613;
3594                                                         }
3595                                                     }
3596                                                 }
3597                                               else
3598                                                 {
3599                                                   if (((word >> 15) & 0x1) == 0)
3600                                                     {
3601                                                       if (((word >> 22) & 0x1) == 0)
3602                                                         {
3603                                                           /* 33222222222211111111110000000000
3604                                                              10987654321098765432109876543210
3605                                                              xx011001100xxxxx0100x1xxxxxxxxxx
3606                                                              cpyfewn.  */
3607                                                           return 2520;
3608                                                         }
3609                                                       else
3610                                                         {
3611                                                           /* 33222222222211111111110000000000
3612                                                              10987654321098765432109876543210
3613                                                              xx011001110xxxxx0100x1xxxxxxxxxx
3614                                                              setm.  */
3615                                                           return 2612;
3616                                                         }
3617                                                     }
3618                                                   else
3619                                                     {
3620                                                       /* 33222222222211111111110000000000
3621                                                          10987654321098765432109876543210
3622                                                          xx0110011x0xxxxx1100x1xxxxxxxxxx
3623                                                          cpyfen.  */
3624                                                       return 2526;
3625                                                     }
3626                                                 }
3627                                             }
3628                                           else
3629                                             {
3630                                               if (((word >> 14) & 0x1) == 0)
3631                                                 {
3632                                                   if (((word >> 15) & 0x1) == 0)
3633                                                     {
3634                                                       if (((word >> 22) & 0x1) == 0)
3635                                                         {
3636                                                           /* 33222222222211111111110000000000
3637                                                              10987654321098765432109876543210
3638                                                              xx011001100xxxxx0010x1xxxxxxxxxx
3639                                                              cpyfert.  */
3640                                                           return 2541;
3641                                                         }
3642                                                       else
3643                                                         {
3644                                                           /* 33222222222211111111110000000000
3645                                                              10987654321098765432109876543210
3646                                                              xx011001110xxxxx0010x1xxxxxxxxxx
3647                                                              setpn.  */
3648                                                           return 2617;
3649                                                         }
3650                                                     }
3651                                                   else
3652                                                     {
3653                                                       if (((word >> 22) & 0x1) == 0)
3654                                                         {
3655                                                           /* 33222222222211111111110000000000
3656                                                              10987654321098765432109876543210
3657                                                              xx011001100xxxxx1010x1xxxxxxxxxx
3658                                                              cpyfertrn.  */
3659                                                           return 2547;
3660                                                         }
3661                                                       else
3662                                                         {
3663                                                           /* 33222222222211111111110000000000
3664                                                              10987654321098765432109876543210
3665                                                              xx011001110xxxxx1010x1xxxxxxxxxx
3666                                                              seten.  */
3667                                                           return 2619;
3668                                                         }
3669                                                     }
3670                                                 }
3671                                               else
3672                                                 {
3673                                                   if (((word >> 15) & 0x1) == 0)
3674                                                     {
3675                                                       if (((word >> 22) & 0x1) == 0)
3676                                                         {
3677                                                           /* 33222222222211111111110000000000
3678                                                              10987654321098765432109876543210
3679                                                              xx011001100xxxxx0110x1xxxxxxxxxx
3680                                                              cpyfertwn.  */
3681                                                           return 2544;
3682                                                         }
3683                                                       else
3684                                                         {
3685                                                           /* 33222222222211111111110000000000
3686                                                              10987654321098765432109876543210
3687                                                              xx011001110xxxxx0110x1xxxxxxxxxx
3688                                                              setmn.  */
3689                                                           return 2618;
3690                                                         }
3691                                                     }
3692                                                   else
3693                                                     {
3694                                                       /* 33222222222211111111110000000000
3695                                                          10987654321098765432109876543210
3696                                                          xx0110011x0xxxxx1110x1xxxxxxxxxx
3697                                                          cpyfertn.  */
3698                                                       return 2550;
3699                                                     }
3700                                                 }
3701                                             }
3702                                         }
3703                                       else
3704                                         {
3705                                           if (((word >> 13) & 0x1) == 0)
3706                                             {
3707                                               if (((word >> 14) & 0x1) == 0)
3708                                                 {
3709                                                   if (((word >> 15) & 0x1) == 0)
3710                                                     {
3711                                                       if (((word >> 22) & 0x1) == 0)
3712                                                         {
3713                                                           /* 33222222222211111111110000000000
3714                                                              10987654321098765432109876543210
3715                                                              xx011001100xxxxx0001x1xxxxxxxxxx
3716                                                              cpyfewt.  */
3717                                                           return 2529;
3718                                                         }
3719                                                       else
3720                                                         {
3721                                                           /* 33222222222211111111110000000000
3722                                                              10987654321098765432109876543210
3723                                                              xx011001110xxxxx0001x1xxxxxxxxxx
3724                                                              setpt.  */
3725                                                           return 2614;
3726                                                         }
3727                                                     }
3728                                                   else
3729                                                     {
3730                                                       if (((word >> 22) & 0x1) == 0)
3731                                                         {
3732                                                           /* 33222222222211111111110000000000
3733                                                              10987654321098765432109876543210
3734                                                              xx011001100xxxxx1001x1xxxxxxxxxx
3735                                                              cpyfewtrn.  */
3736                                                           return 2535;
3737                                                         }
3738                                                       else
3739                                                         {
3740                                                           /* 33222222222211111111110000000000
3741                                                              10987654321098765432109876543210
3742                                                              xx011001110xxxxx1001x1xxxxxxxxxx
3743                                                              setet.  */
3744                                                           return 2616;
3745                                                         }
3746                                                     }
3747                                                 }
3748                                               else
3749                                                 {
3750                                                   if (((word >> 15) & 0x1) == 0)
3751                                                     {
3752                                                       if (((word >> 22) & 0x1) == 0)
3753                                                         {
3754                                                           /* 33222222222211111111110000000000
3755                                                              10987654321098765432109876543210
3756                                                              xx011001100xxxxx0101x1xxxxxxxxxx
3757                                                              cpyfewtwn.  */
3758                                                           return 2532;
3759                                                         }
3760                                                       else
3761                                                         {
3762                                                           /* 33222222222211111111110000000000
3763                                                              10987654321098765432109876543210
3764                                                              xx011001110xxxxx0101x1xxxxxxxxxx
3765                                                              setmt.  */
3766                                                           return 2615;
3767                                                         }
3768                                                     }
3769                                                   else
3770                                                     {
3771                                                       /* 33222222222211111111110000000000
3772                                                          10987654321098765432109876543210
3773                                                          xx0110011x0xxxxx1101x1xxxxxxxxxx
3774                                                          cpyfewtn.  */
3775                                                       return 2538;
3776                                                     }
3777                                                 }
3778                                             }
3779                                           else
3780                                             {
3781                                               if (((word >> 14) & 0x1) == 0)
3782                                                 {
3783                                                   if (((word >> 15) & 0x1) == 0)
3784                                                     {
3785                                                       if (((word >> 22) & 0x1) == 0)
3786                                                         {
3787                                                           /* 33222222222211111111110000000000
3788                                                              10987654321098765432109876543210
3789                                                              xx011001100xxxxx0011x1xxxxxxxxxx
3790                                                              cpyfet.  */
3791                                                           return 2553;
3792                                                         }
3793                                                       else
3794                                                         {
3795                                                           /* 33222222222211111111110000000000
3796                                                              10987654321098765432109876543210
3797                                                              xx011001110xxxxx0011x1xxxxxxxxxx
3798                                                              setptn.  */
3799                                                           return 2620;
3800                                                         }
3801                                                     }
3802                                                   else
3803                                                     {
3804                                                       if (((word >> 22) & 0x1) == 0)
3805                                                         {
3806                                                           /* 33222222222211111111110000000000
3807                                                              10987654321098765432109876543210
3808                                                              xx011001100xxxxx1011x1xxxxxxxxxx
3809                                                              cpyfetrn.  */
3810                                                           return 2559;
3811                                                         }
3812                                                       else
3813                                                         {
3814                                                           /* 33222222222211111111110000000000
3815                                                              10987654321098765432109876543210
3816                                                              xx011001110xxxxx1011x1xxxxxxxxxx
3817                                                              setetn.  */
3818                                                           return 2622;
3819                                                         }
3820                                                     }
3821                                                 }
3822                                               else
3823                                                 {
3824                                                   if (((word >> 15) & 0x1) == 0)
3825                                                     {
3826                                                       if (((word >> 22) & 0x1) == 0)
3827                                                         {
3828                                                           /* 33222222222211111111110000000000
3829                                                              10987654321098765432109876543210
3830                                                              xx011001100xxxxx0111x1xxxxxxxxxx
3831                                                              cpyfetwn.  */
3832                                                           return 2556;
3833                                                         }
3834                                                       else
3835                                                         {
3836                                                           /* 33222222222211111111110000000000
3837                                                              10987654321098765432109876543210
3838                                                              xx011001110xxxxx0111x1xxxxxxxxxx
3839                                                              setmtn.  */
3840                                                           return 2621;
3841                                                         }
3842                                                     }
3843                                                   else
3844                                                     {
3845                                                       /* 33222222222211111111110000000000
3846                                                          10987654321098765432109876543210
3847                                                          xx0110011x0xxxxx1111x1xxxxxxxxxx
3848                                                          cpyfetn.  */
3849                                                       return 2562;
3850                                                     }
3851                                                 }
3852                                             }
3853                                         }
3854                                     }
3855                                   else
3856                                     {
3857                                       if (((word >> 22) & 0x1) == 0)
3858                                         {
3859                                           /* 33222222222211111111110000000000
3860                                              10987654321098765432109876543210
3861                                              xx011001101xxxxxxxxxx1xxxxxxxxxx
3862                                              st2g.  */
3863                                           return 887;
3864                                         }
3865                                       else
3866                                         {
3867                                           /* 33222222222211111111110000000000
3868                                              10987654321098765432109876543210
3869                                              xx011001111xxxxxxxxxx1xxxxxxxxxx
3870                                              stz2g.  */
3871                                           return 888;
3872                                         }
3873                                     }
3874                                 }
3875                             }
3876                           else
3877                             {
3878                               if (((word >> 30) & 0x1) == 0)
3879                                 {
3880                                   if (((word >> 31) & 0x1) == 0)
3881                                     {
3882                                       /* 33222222222211111111110000000000
3883                                          10987654321098765432109876543210
3884                                          001110011xxxxxxxxxxxxxxxxxxxxxxx
3885                                          ldrsb.  */
3886                                       return 891;
3887                                     }
3888                                   else
3889                                     {
3890                                       /* 33222222222211111111110000000000
3891                                          10987654321098765432109876543210
3892                                          101110011xxxxxxxxxxxxxxxxxxxxxxx
3893                                          ldrsw.  */
3894                                       return 899;
3895                                     }
3896                                 }
3897                               else
3898                                 {
3899                                   if (((word >> 31) & 0x1) == 0)
3900                                     {
3901                                       /* 33222222222211111111110000000000
3902                                          10987654321098765432109876543210
3903                                          011110011xxxxxxxxxxxxxxxxxxxxxxx
3904                                          ldrsh.  */
3905                                       return 896;
3906                                     }
3907                                   else
3908                                     {
3909                                       /* 33222222222211111111110000000000
3910                                          10987654321098765432109876543210
3911                                          111110011xxxxxxxxxxxxxxxxxxxxxxx
3912                                          prfm.  */
3913                                       return 900;
3914                                     }
3915                                 }
3916                             }
3917                         }
3918                     }
3919                 }
3920             }
3921         }
3922       else
3923         {
3924           if (((word >> 24) & 0x1) == 0)
3925             {
3926               if (((word >> 27) & 0x1) == 0)
3927                 {
3928                   if (((word >> 23) & 0x1) == 0)
3929                     {
3930                       if (((word >> 29) & 0x1) == 0)
3931                         {
3932                           if (((word >> 30) & 0x1) == 0)
3933                             {
3934                               /* 33222222222211111111110000000000
3935                                  10987654321098765432109876543210
3936                                  x00x00100xxxxxxxxxxxxxxxxxxxxxxx
3937                                  and.  */
3938                               return 995;
3939                             }
3940                           else
3941                             {
3942                               /* 33222222222211111111110000000000
3943                                  10987654321098765432109876543210
3944                                  x10x00100xxxxxxxxxxxxxxxxxxxxxxx
3945                                  eor.  */
3946                               return 999;
3947                             }
3948                         }
3949                       else
3950                         {
3951                           if (((word >> 30) & 0x1) == 0)
3952                             {
3953                               /* 33222222222211111111110000000000
3954                                  10987654321098765432109876543210
3955                                  x01x00100xxxxxxxxxxxxxxxxxxxxxxx
3956                                  orr.  */
3957                               return 997;
3958                             }
3959                           else
3960                             {
3961                               /* 33222222222211111111110000000000
3962                                  10987654321098765432109876543210
3963                                  x11x00100xxxxxxxxxxxxxxxxxxxxxxx
3964                                  ands.  */
3965                               return 1000;
3966                             }
3967                         }
3968                     }
3969                   else
3970                     {
3971                       if (((word >> 29) & 0x1) == 0)
3972                         {
3973                           if (((word >> 30) & 0x1) == 0)
3974                             {
3975                               /* 33222222222211111111110000000000
3976                                  10987654321098765432109876543210
3977                                  x00x00101xxxxxxxxxxxxxxxxxxxxxxx
3978                                  movn.  */
3979                               return 1186;
3980                             }
3981                           else
3982                             {
3983                               /* 33222222222211111111110000000000
3984                                  10987654321098765432109876543210
3985                                  x10x00101xxxxxxxxxxxxxxxxxxxxxxx
3986                                  movz.  */
3987                               return 1188;
3988                             }
3989                         }
3990                       else
3991                         {
3992                           /* 33222222222211111111110000000000
3993                              10987654321098765432109876543210
3994                              xx1x00101xxxxxxxxxxxxxxxxxxxxxxx
3995                              movk.  */
3996                           return 1190;
3997                         }
3998                     }
3999                 }
4000               else
4001                 {
4002                   if (((word >> 21) & 0x1) == 0)
4003                     {
4004                       if (((word >> 28) & 0x1) == 0)
4005                         {
4006                           if (((word >> 29) & 0x1) == 0)
4007                             {
4008                               if (((word >> 30) & 0x1) == 0)
4009                                 {
4010                                   /* 33222222222211111111110000000000
4011                                      10987654321098765432109876543210
4012                                      x0001010xx0xxxxxxxxxxxxxxxxxxxxx
4013                                      and.  */
4014                                   return 1002;
4015                                 }
4016                               else
4017                                 {
4018                                   /* 33222222222211111111110000000000
4019                                      10987654321098765432109876543210
4020                                      x1001010xx0xxxxxxxxxxxxxxxxxxxxx
4021                                      eor.  */
4022                                   return 1009;
4023                                 }
4024                             }
4025                           else
4026                             {
4027                               if (((word >> 30) & 0x1) == 0)
4028                                 {
4029                                   /* 33222222222211111111110000000000
4030                                      10987654321098765432109876543210
4031                                      x0101010xx0xxxxxxxxxxxxxxxxxxxxx
4032                                      orr.  */
4033                                   return 1004;
4034                                 }
4035                               else
4036                                 {
4037                                   /* 33222222222211111111110000000000
4038                                      10987654321098765432109876543210
4039                                      x1101010xx0xxxxxxxxxxxxxxxxxxxxx
4040                                      ands.  */
4041                                   return 1011;
4042                                 }
4043                             }
4044                         }
4045                       else
4046                         {
4047                           if (((word >> 10) & 0x1) == 0)
4048                             {
4049                               if (((word >> 11) & 0x1) == 0)
4050                                 {
4051                                   if (((word >> 22) & 0x1) == 0)
4052                                     {
4053                                       if (((word >> 23) & 0x1) == 0)
4054                                         {
4055                                           if (((word >> 29) & 0x1) == 0)
4056                                             {
4057                                               if (((word >> 30) & 0x1) == 0)
4058                                                 {
4059                                                   /* 33222222222211111111110000000000
4060                                                      10987654321098765432109876543210
4061                                                      x0011010000xxxxxxxxx00xxxxxxxxxx
4062                                                      adc.  */
4063                                                   return 0;
4064                                                 }
4065                                               else
4066                                                 {
4067                                                   /* 33222222222211111111110000000000
4068                                                      10987654321098765432109876543210
4069                                                      x1011010000xxxxxxxxx00xxxxxxxxxx
4070                                                      sbc.  */
4071                                                   return 2;
4072                                                 }
4073                                             }
4074                                           else
4075                                             {
4076                                               if (((word >> 30) & 0x1) == 0)
4077                                                 {
4078                                                   /* 33222222222211111111110000000000
4079                                                      10987654321098765432109876543210
4080                                                      x0111010000xxxxxxxxx00xxxxxxxxxx
4081                                                      adcs.  */
4082                                                   return 1;
4083                                                 }
4084                                               else
4085                                                 {
4086                                                   /* 33222222222211111111110000000000
4087                                                      10987654321098765432109876543210
4088                                                      x1111010000xxxxxxxxx00xxxxxxxxxx
4089                                                      sbcs.  */
4090                                                   return 4;
4091                                                 }
4092                                             }
4093                                         }
4094                                       else
4095                                         {
4096                                           if (((word >> 30) & 0x1) == 0)
4097                                             {
4098                                               /* 33222222222211111111110000000000
4099                                                  10987654321098765432109876543210
4100                                                  x0x11010100xxxxxxxxx00xxxxxxxxxx
4101                                                  csel.  */
4102                                               return 662;
4103                                             }
4104                                           else
4105                                             {
4106                                               /* 33222222222211111111110000000000
4107                                                  10987654321098765432109876543210
4108                                                  x1x11010100xxxxxxxxx00xxxxxxxxxx
4109                                                  csinv.  */
4110                                               return 666;
4111                                             }
4112                                         }
4113                                     }
4114                                   else
4115                                     {
4116                                       if (((word >> 23) & 0x1) == 0)
4117                                         {
4118                                           if (((word >> 30) & 0x1) == 0)
4119                                             {
4120                                               /* 33222222222211111111110000000000
4121                                                  10987654321098765432109876543210
4122                                                  x0x11010010xxxxxxxxx00xxxxxxxxxx
4123                                                  ccmn.  */
4124                                               return 660;
4125                                             }
4126                                           else
4127                                             {
4128                                               /* 33222222222211111111110000000000
4129                                                  10987654321098765432109876543210
4130                                                  x1x11010010xxxxxxxxx00xxxxxxxxxx
4131                                                  ccmp.  */
4132                                               return 661;
4133                                             }
4134                                         }
4135                                       else
4136                                         {
4137                                           if (((word >> 12) & 0x1) == 0)
4138                                             {
4139                                               if (((word >> 13) & 0x1) == 0)
4140                                                 {
4141                                                   if (((word >> 14) & 0x1) == 0)
4142                                                     {
4143                                                       if (((word >> 29) & 0x1) == 0)
4144                                                         {
4145                                                           if (((word >> 30) & 0x1) == 0)
4146                                                             {
4147                                                               /* 33222222222211111111110000000000
4148                                                                  10987654321098765432109876543210
4149                                                                  x0011010110xxxxxx00000xxxxxxxxxx
4150                                                                  subp.  */
4151                                                               return 721;
4152                                                             }
4153                                                           else
4154                                                             {
4155                                                               if (((word >> 16) & 0x1) == 0)
4156                                                                 {
4157                                                                   /* 33222222222211111111110000000000
4158                                                                      10987654321098765432109876543210
4159                                                                      x1011010110xxxx0x00000xxxxxxxxxx
4160                                                                      rbit.  */
4161                                                                   return 685;
4162                                                                 }
4163                                                               else
4164                                                                 {
4165                                                                   /* 33222222222211111111110000000000
4166                                                                      10987654321098765432109876543210
4167                                                                      x1011010110xxxx1x00000xxxxxxxxxx
4168                                                                      pacia.  */
4169                                                                   return 693;
4170                                                                 }
4171                                                             }
4172                                                         }
4173                                                       else
4174                                                         {
4175                                                           /* 33222222222211111111110000000000
4176                                                              10987654321098765432109876543210
4177                                                              xx111010110xxxxxx00000xxxxxxxxxx
4178                                                              subps.  */
4179                                                           return 722;
4180                                                         }
4181                                                     }
4182                                                   else
4183                                                     {
4184                                                       if (((word >> 30) & 0x1) == 0)
4185                                                         {
4186                                                           /* 33222222222211111111110000000000
4187                                                              10987654321098765432109876543210
4188                                                              x0x11010110xxxxxx10000xxxxxxxxxx
4189                                                              crc32b.  */
4190                                                           return 727;
4191                                                         }
4192                                                       else
4193                                                         {
4194                                                           /* 33222222222211111111110000000000
4195                                                              10987654321098765432109876543210
4196                                                              x1x11010110xxxxxx10000xxxxxxxxxx
4197                                                              xpaci.  */
4198                                                           return 709;
4199                                                         }
4200                                                     }
4201                                                 }
4202                                               else
4203                                                 {
4204                                                   if (((word >> 14) & 0x1) == 0)
4205                                                     {
4206                                                       if (((word >> 30) & 0x1) == 0)
4207                                                         {
4208                                                           /* 33222222222211111111110000000000
4209                                                              10987654321098765432109876543210
4210                                                              x0x11010110xxxxxx01000xxxxxxxxxx
4211                                                              lslv.  */
4212                                                           return 713;
4213                                                         }
4214                                                       else
4215                                                         {
4216                                                           if (((word >> 16) & 0x1) == 0)
4217                                                             {
4218                                                               /* 33222222222211111111110000000000
4219                                                                  10987654321098765432109876543210
4220                                                                  x1x11010110xxxx0x01000xxxxxxxxxx
4221                                                                  abs.  */
4222                                                               return 2640;
4223                                                             }
4224                                                           else
4225                                                             {
4226                                                               /* 33222222222211111111110000000000
4227                                                                  10987654321098765432109876543210
4228                                                                  x1x11010110xxxx1x01000xxxxxxxxxx
4229                                                                  paciza.  */
4230                                                               return 701;
4231                                                             }
4232                                                         }
4233                                                     }
4234                                                   else
4235                                                     {
4236                                                       /* 33222222222211111111110000000000
4237                                                          10987654321098765432109876543210
4238                                                          xxx11010110xxxxxx11000xxxxxxxxxx
4239                                                          smax.  */
4240                                                       return 2643;
4241                                                     }
4242                                                 }
4243                                             }
4244                                           else
4245                                             {
4246                                               if (((word >> 13) & 0x1) == 0)
4247                                                 {
4248                                                   if (((word >> 14) & 0x1) == 0)
4249                                                     {
4250                                                       if (((word >> 30) & 0x1) == 0)
4251                                                         {
4252                                                           /* 33222222222211111111110000000000
4253                                                              10987654321098765432109876543210
4254                                                              x0x11010110xxxxxx00100xxxxxxxxxx
4255                                                              irg.  */
4256                                                           return 724;
4257                                                         }
4258                                                       else
4259                                                         {
4260                                                           if (((word >> 16) & 0x1) == 0)
4261                                                             {
4262                                                               /* 33222222222211111111110000000000
4263                                                                  10987654321098765432109876543210
4264                                                                  x1x11010110xxxx0x00100xxxxxxxxxx
4265                                                                  clz.  */
4266                                                               return 690;
4267                                                             }
4268                                                           else
4269                                                             {
4270                                                               /* 33222222222211111111110000000000
4271                                                                  10987654321098765432109876543210
4272                                                                  x1x11010110xxxx1x00100xxxxxxxxxx
4273                                                                  autia.  */
4274                                                               return 697;
4275                                                             }
4276                                                         }
4277                                                     }
4278                                                   else
4279                                                     {
4280                                                       /* 33222222222211111111110000000000
4281                                                          10987654321098765432109876543210
4282                                                          xxx11010110xxxxxx10100xxxxxxxxxx
4283                                                          crc32cb.  */
4284                                                       return 731;
4285                                                     }
4286                                                 }
4287                                               else
4288                                                 {
4289                                                   if (((word >> 30) & 0x1) == 0)
4290                                                     {
4291                                                       /* 33222222222211111111110000000000
4292                                                          10987654321098765432109876543210
4293                                                          x0x11010110xxxxxxx1100xxxxxxxxxx
4294                                                          pacga.  */
4295                                                       return 726;
4296                                                     }
4297                                                   else
4298                                                     {
4299                                                       /* 33222222222211111111110000000000
4300                                                          10987654321098765432109876543210
4301                                                          x1x11010110xxxxxxx1100xxxxxxxxxx
4302                                                          autiza.  */
4303                                                       return 705;
4304                                                     }
4305                                                 }
4306                                             }
4307                                         }
4308                                     }
4309                                 }
4310                               else
4311                                 {
4312                                   if (((word >> 22) & 0x1) == 0)
4313                                     {
4314                                       if (((word >> 14) & 0x1) == 0)
4315                                         {
4316                                           /* 33222222222211111111110000000000
4317                                              10987654321098765432109876543210
4318                                              xxx11010x00xxxxxx0xx10xxxxxxxxxx
4319                                              setf8.  */
4320                                           return 2453;
4321                                         }
4322                                       else
4323                                         {
4324                                           /* 33222222222211111111110000000000
4325                                              10987654321098765432109876543210
4326                                              xxx11010x00xxxxxx1xx10xxxxxxxxxx
4327                                              setf16.  */
4328                                           return 2454;
4329                                         }
4330                                     }
4331                                   else
4332                                     {
4333                                       if (((word >> 23) & 0x1) == 0)
4334                                         {
4335                                           if (((word >> 30) & 0x1) == 0)
4336                                             {
4337                                               /* 33222222222211111111110000000000
4338                                                  10987654321098765432109876543210
4339                                                  x0x11010010xxxxxxxxx10xxxxxxxxxx
4340                                                  ccmn.  */
4341                                               return 658;
4342                                             }
4343                                           else
4344                                             {
4345                                               /* 33222222222211111111110000000000
4346                                                  10987654321098765432109876543210
4347                                                  x1x11010010xxxxxxxxx10xxxxxxxxxx
4348                                                  ccmp.  */
4349                                               return 659;
4350                                             }
4351                                         }
4352                                       else
4353                                         {
4354                                           if (((word >> 12) & 0x1) == 0)
4355                                             {
4356                                               if (((word >> 13) & 0x1) == 0)
4357                                                 {
4358                                                   if (((word >> 14) & 0x1) == 0)
4359                                                     {
4360                                                       if (((word >> 30) & 0x1) == 0)
4361                                                         {
4362                                                           /* 33222222222211111111110000000000
4363                                                              10987654321098765432109876543210
4364                                                              x0x11010110xxxxxx00010xxxxxxxxxx
4365                                                              udiv.  */
4366                                                           return 711;
4367                                                         }
4368                                                       else
4369                                                         {
4370                                                           if (((word >> 16) & 0x1) == 0)
4371                                                             {
4372                                                               if (((word >> 31) & 0x1) == 0)
4373                                                                 {
4374                                                                   /* 33222222222211111111110000000000
4375                                                                      10987654321098765432109876543210
4376                                                                      01x11010110xxxx0x00010xxxxxxxxxx
4377                                                                      rev.  */
4378                                                                   return 687;
4379                                                                 }
4380                                                               else
4381                                                                 {
4382                                                                   /* 33222222222211111111110000000000
4383                                                                      10987654321098765432109876543210
4384                                                                      11x11010110xxxx0x00010xxxxxxxxxx
4385                                                                      rev32.  */
4386                                                                   return 692;
4387                                                                 }
4388                                                             }
4389                                                           else
4390                                                             {
4391                                                               /* 33222222222211111111110000000000
4392                                                                  10987654321098765432109876543210
4393                                                                  x1x11010110xxxx1x00010xxxxxxxxxx
4394                                                                  pacda.  */
4395                                                               return 695;
4396                                                             }
4397                                                         }
4398                                                     }
4399                                                   else
4400                                                     {
4401                                                       /* 33222222222211111111110000000000
4402                                                          10987654321098765432109876543210
4403                                                          xxx11010110xxxxxx10010xxxxxxxxxx
4404                                                          crc32w.  */
4405                                                       return 729;
4406                                                     }
4407                                                 }
4408                                               else
4409                                                 {
4410                                                   if (((word >> 14) & 0x1) == 0)
4411                                                     {
4412                                                       if (((word >> 30) & 0x1) == 0)
4413                                                         {
4414                                                           /* 33222222222211111111110000000000
4415                                                              10987654321098765432109876543210
4416                                                              x0x11010110xxxxxx01010xxxxxxxxxx
4417                                                              asrv.  */
4418                                                           return 717;
4419                                                         }
4420                                                       else
4421                                                         {
4422                                                           /* 33222222222211111111110000000000
4423                                                              10987654321098765432109876543210
4424                                                              x1x11010110xxxxxx01010xxxxxxxxxx
4425                                                              pacdza.  */
4426                                                           return 703;
4427                                                         }
4428                                                     }
4429                                                   else
4430                                                     {
4431                                                       /* 33222222222211111111110000000000
4432                                                          10987654321098765432109876543210
4433                                                          xxx11010110xxxxxx11010xxxxxxxxxx
4434                                                          smin.  */
4435                                                       return 2645;
4436                                                     }
4437                                                 }
4438                                             }
4439                                           else
4440                                             {
4441                                               if (((word >> 13) & 0x1) == 0)
4442                                                 {
4443                                                   if (((word >> 14) & 0x1) == 0)
4444                                                     {
4445                                                       if (((word >> 16) & 0x1) == 0)
4446                                                         {
4447                                                           /* 33222222222211111111110000000000
4448                                                              10987654321098765432109876543210
4449                                                              xxx11010110xxxx0x00110xxxxxxxxxx
4450                                                              ctz.  */
4451                                                           return 2642;
4452                                                         }
4453                                                       else
4454                                                         {
4455                                                           /* 33222222222211111111110000000000
4456                                                              10987654321098765432109876543210
4457                                                              xxx11010110xxxx1x00110xxxxxxxxxx
4458                                                              autda.  */
4459                                                           return 699;
4460                                                         }
4461                                                     }
4462                                                   else
4463                                                     {
4464                                                       /* 33222222222211111111110000000000
4465                                                          10987654321098765432109876543210
4466                                                          xxx11010110xxxxxx10110xxxxxxxxxx
4467                                                          crc32cw.  */
4468                                                       return 733;
4469                                                     }
4470                                                 }
4471                                               else
4472                                                 {
4473                                                   /* 33222222222211111111110000000000
4474                                                      10987654321098765432109876543210
4475                                                      xxx11010110xxxxxxx1110xxxxxxxxxx
4476                                                      autdza.  */
4477                                                   return 707;
4478                                                 }
4479                                             }
4480                                         }
4481                                     }
4482                                 }
4483                             }
4484                           else
4485                             {
4486                               if (((word >> 11) & 0x1) == 0)
4487                                 {
4488                                   if (((word >> 22) & 0x1) == 0)
4489                                     {
4490                                       if (((word >> 23) & 0x1) == 0)
4491                                         {
4492                                           /* 33222222222211111111110000000000
4493                                              10987654321098765432109876543210
4494                                              xxx11010000xxxxxxxxx01xxxxxxxxxx
4495                                              rmif.  */
4496                                           return 2452;
4497                                         }
4498                                       else
4499                                         {
4500                                           if (((word >> 30) & 0x1) == 0)
4501                                             {
4502                                               /* 33222222222211111111110000000000
4503                                                  10987654321098765432109876543210
4504                                                  x0x11010100xxxxxxxxx01xxxxxxxxxx
4505                                                  csinc.  */
4506                                               return 663;
4507                                             }
4508                                           else
4509                                             {
4510                                               /* 33222222222211111111110000000000
4511                                                  10987654321098765432109876543210
4512                                                  x1x11010100xxxxxxxxx01xxxxxxxxxx
4513                                                  csneg.  */
4514                                               return 669;
4515                                             }
4516                                         }
4517                                     }
4518                                   else
4519                                     {
4520                                       if (((word >> 12) & 0x1) == 0)
4521                                         {
4522                                           if (((word >> 13) & 0x1) == 0)
4523                                             {
4524                                               if (((word >> 14) & 0x1) == 0)
4525                                                 {
4526                                                   if (((word >> 16) & 0x1) == 0)
4527                                                     {
4528                                                       /* 33222222222211111111110000000000
4529                                                          10987654321098765432109876543210
4530                                                          xxx11010x10xxxx0x00001xxxxxxxxxx
4531                                                          rev16.  */
4532                                                       return 686;
4533                                                     }
4534                                                   else
4535                                                     {
4536                                                       /* 33222222222211111111110000000000
4537                                                          10987654321098765432109876543210
4538                                                          xxx11010x10xxxx1x00001xxxxxxxxxx
4539                                                          pacib.  */
4540                                                       return 694;
4541                                                     }
4542                                                 }
4543                                               else
4544                                                 {
4545                                                   if (((word >> 30) & 0x1) == 0)
4546                                                     {
4547                                                       /* 33222222222211111111110000000000
4548                                                          10987654321098765432109876543210
4549                                                          x0x11010x10xxxxxx10001xxxxxxxxxx
4550                                                          crc32h.  */
4551                                                       return 728;
4552                                                     }
4553                                                   else
4554                                                     {
4555                                                       /* 33222222222211111111110000000000
4556                                                          10987654321098765432109876543210
4557                                                          x1x11010x10xxxxxx10001xxxxxxxxxx
4558                                                          xpacd.  */
4559                                                       return 710;
4560                                                     }
4561                                                 }
4562                                             }
4563                                           else
4564                                             {
4565                                               if (((word >> 14) & 0x1) == 0)
4566                                                 {
4567                                                   if (((word >> 30) & 0x1) == 0)
4568                                                     {
4569                                                       /* 33222222222211111111110000000000
4570                                                          10987654321098765432109876543210
4571                                                          x0x11010x10xxxxxx01001xxxxxxxxxx
4572                                                          lsrv.  */
4573                                                       return 715;
4574                                                     }
4575                                                   else
4576                                                     {
4577                                                       /* 33222222222211111111110000000000
4578                                                          10987654321098765432109876543210
4579                                                          x1x11010x10xxxxxx01001xxxxxxxxxx
4580                                                          pacizb.  */
4581                                                       return 702;
4582                                                     }
4583                                                 }
4584                                               else
4585                                                 {
4586                                                   /* 33222222222211111111110000000000
4587                                                      10987654321098765432109876543210
4588                                                      xxx11010x10xxxxxx11001xxxxxxxxxx
4589                                                      umax.  */
4590                                                   return 2644;
4591                                                 }
4592                                             }
4593                                         }
4594                                       else
4595                                         {
4596                                           if (((word >> 13) & 0x1) == 0)
4597                                             {
4598                                               if (((word >> 14) & 0x1) == 0)
4599                                                 {
4600                                                   if (((word >> 30) & 0x1) == 0)
4601                                                     {
4602                                                       /* 33222222222211111111110000000000
4603                                                          10987654321098765432109876543210
4604                                                          x0x11010x10xxxxxx00101xxxxxxxxxx
4605                                                          gmi.  */
4606                                                       return 725;
4607                                                     }
4608                                                   else
4609                                                     {
4610                                                       if (((word >> 16) & 0x1) == 0)
4611                                                         {
4612                                                           /* 33222222222211111111110000000000
4613                                                              10987654321098765432109876543210
4614                                                              x1x11010x10xxxx0x00101xxxxxxxxxx
4615                                                              cls.  */
4616                                                           return 691;
4617                                                         }
4618                                                       else
4619                                                         {
4620                                                           /* 33222222222211111111110000000000
4621                                                              10987654321098765432109876543210
4622                                                              x1x11010x10xxxx1x00101xxxxxxxxxx
4623                                                              autib.  */
4624                                                           return 698;
4625                                                         }
4626                                                     }
4627                                                 }
4628                                               else
4629                                                 {
4630                                                   /* 33222222222211111111110000000000
4631                                                      10987654321098765432109876543210
4632                                                      xxx11010x10xxxxxx10101xxxxxxxxxx
4633                                                      crc32ch.  */
4634                                                   return 732;
4635                                                 }
4636                                             }
4637                                           else
4638                                             {
4639                                               /* 33222222222211111111110000000000
4640                                                  10987654321098765432109876543210
4641                                                  xxx11010x10xxxxxxx1101xxxxxxxxxx
4642                                                  autizb.  */
4643                                               return 706;
4644                                             }
4645                                         }
4646                                     }
4647                                 }
4648                               else
4649                                 {
4650                                   if (((word >> 12) & 0x1) == 0)
4651                                     {
4652                                       if (((word >> 13) & 0x1) == 0)
4653                                         {
4654                                           if (((word >> 14) & 0x1) == 0)
4655                                             {
4656                                               if (((word >> 30) & 0x1) == 0)
4657                                                 {
4658                                                   /* 33222222222211111111110000000000
4659                                                      10987654321098765432109876543210
4660                                                      x0x11010xx0xxxxxx00011xxxxxxxxxx
4661                                                      sdiv.  */
4662                                                   return 712;
4663                                                 }
4664                                               else
4665                                                 {
4666                                                   if (((word >> 16) & 0x1) == 0)
4667                                                     {
4668                                                       /* 33222222222211111111110000000000
4669                                                          10987654321098765432109876543210
4670                                                          x1x11010xx0xxxx0x00011xxxxxxxxxx
4671                                                          rev.  */
4672                                                       return 688;
4673                                                     }
4674                                                   else
4675                                                     {
4676                                                       /* 33222222222211111111110000000000
4677                                                          10987654321098765432109876543210
4678                                                          x1x11010xx0xxxx1x00011xxxxxxxxxx
4679                                                          pacdb.  */
4680                                                       return 696;
4681                                                     }
4682                                                 }
4683                                             }
4684                                           else
4685                                             {
4686                                               /* 33222222222211111111110000000000
4687                                                  10987654321098765432109876543210
4688                                                  xxx11010xx0xxxxxx10011xxxxxxxxxx
4689                                                  crc32x.  */
4690                                               return 730;
4691                                             }
4692                                         }
4693                                       else
4694                                         {
4695                                           if (((word >> 14) & 0x1) == 0)
4696                                             {
4697                                               if (((word >> 30) & 0x1) == 0)
4698                                                 {
4699                                                   /* 33222222222211111111110000000000
4700                                                      10987654321098765432109876543210
4701                                                      x0x11010xx0xxxxxx01011xxxxxxxxxx
4702                                                      rorv.  */
4703                                                   return 719;
4704                                                 }
4705                                               else
4706                                                 {
4707                                                   /* 33222222222211111111110000000000
4708                                                      10987654321098765432109876543210
4709                                                      x1x11010xx0xxxxxx01011xxxxxxxxxx
4710                                                      pacdzb.  */
4711                                                   return 704;
4712                                                 }
4713                                             }
4714                                           else
4715                                             {
4716                                               /* 33222222222211111111110000000000
4717                                                  10987654321098765432109876543210
4718                                                  xxx11010xx0xxxxxx11011xxxxxxxxxx
4719                                                  umin.  */
4720                                               return 2646;
4721                                             }
4722                                         }
4723                                     }
4724                                   else
4725                                     {
4726                                       if (((word >> 13) & 0x1) == 0)
4727                                         {
4728                                           if (((word >> 14) & 0x1) == 0)
4729                                             {
4730                                               if (((word >> 16) & 0x1) == 0)
4731                                                 {
4732                                                   /* 33222222222211111111110000000000
4733                                                      10987654321098765432109876543210
4734                                                      xxx11010xx0xxxx0x00111xxxxxxxxxx
4735                                                      cnt.  */
4736                                                   return 2641;
4737                                                 }
4738                                               else
4739                                                 {
4740                                                   /* 33222222222211111111110000000000
4741                                                      10987654321098765432109876543210
4742                                                      xxx11010xx0xxxx1x00111xxxxxxxxxx
4743                                                      autdb.  */
4744                                                   return 700;
4745                                                 }
4746                                             }
4747                                           else
4748                                             {
4749                                               /* 33222222222211111111110000000000
4750                                                  10987654321098765432109876543210
4751                                                  xxx11010xx0xxxxxx10111xxxxxxxxxx
4752                                                  crc32cx.  */
4753                                               return 734;
4754                                             }
4755                                         }
4756                                       else
4757                                         {
4758                                           /* 33222222222211111111110000000000
4759                                              10987654321098765432109876543210
4760                                              xxx11010xx0xxxxxxx1111xxxxxxxxxx
4761                                              autdzb.  */
4762                                           return 708;
4763                                         }
4764                                     }
4765                                 }
4766                             }
4767                         }
4768                     }
4769                   else
4770                     {
4771                       if (((word >> 29) & 0x1) == 0)
4772                         {
4773                           if (((word >> 30) & 0x1) == 0)
4774                             {
4775                               /* 33222222222211111111110000000000
4776                                  10987654321098765432109876543210
4777                                  x00x1010xx1xxxxxxxxxxxxxxxxxxxxx
4778                                  bic.  */
4779                               return 1003;
4780                             }
4781                           else
4782                             {
4783                               /* 33222222222211111111110000000000
4784                                  10987654321098765432109876543210
4785                                  x10x1010xx1xxxxxxxxxxxxxxxxxxxxx
4786                                  eon.  */
4787                               return 1010;
4788                             }
4789                         }
4790                       else
4791                         {
4792                           if (((word >> 30) & 0x1) == 0)
4793                             {
4794                               /* 33222222222211111111110000000000
4795                                  10987654321098765432109876543210
4796                                  x01x1010xx1xxxxxxxxxxxxxxxxxxxxx
4797                                  orn.  */
4798                               return 1007;
4799                             }
4800                           else
4801                             {
4802                               /* 33222222222211111111110000000000
4803                                  10987654321098765432109876543210
4804                                  x11x1010xx1xxxxxxxxxxxxxxxxxxxxx
4805                                  bics.  */
4806                               return 1013;
4807                             }
4808                         }
4809                     }
4810                 }
4811             }
4812           else
4813             {
4814               if (((word >> 27) & 0x1) == 0)
4815                 {
4816                   if (((word >> 23) & 0x1) == 0)
4817                     {
4818                       if (((word >> 29) & 0x1) == 0)
4819                         {
4820                           if (((word >> 30) & 0x1) == 0)
4821                             {
4822                               /* 33222222222211111111110000000000
4823                                  10987654321098765432109876543210
4824                                  x00x00110xxxxxxxxxxxxxxxxxxxxxxx
4825                                  sbfm.  */
4826                               return 618;
4827                             }
4828                           else
4829                             {
4830                               /* 33222222222211111111110000000000
4831                                  10987654321098765432109876543210
4832                                  x10x00110xxxxxxxxxxxxxxxxxxxxxxx
4833                                  ubfm.  */
4834                               return 629;
4835                             }
4836                         }
4837                       else
4838                         {
4839                           /* 33222222222211111111110000000000
4840                              10987654321098765432109876543210
4841                              xx1x00110xxxxxxxxxxxxxxxxxxxxxxx
4842                              bfm.  */
4843                           return 625;
4844                         }
4845                     }
4846                   else
4847                     {
4848                       /* 33222222222211111111110000000000
4849                          10987654321098765432109876543210
4850                          xxxx00111xxxxxxxxxxxxxxxxxxxxxxx
4851                          extr.  */
4852                       return 758;
4853                     }
4854                 }
4855               else
4856                 {
4857                   if (((word >> 21) & 0x1) == 0)
4858                     {
4859                       if (((word >> 28) & 0x1) == 0)
4860                         {
4861                           if (((word >> 29) & 0x1) == 0)
4862                             {
4863                               if (((word >> 30) & 0x1) == 0)
4864                                 {
4865                                   /* 33222222222211111111110000000000
4866                                      10987654321098765432109876543210
4867                                      x0001011xx0xxxxxxxxxxxxxxxxxxxxx
4868                                      add.  */
4869                                   return 21;
4870                                 }
4871                               else
4872                                 {
4873                                   /* 33222222222211111111110000000000
4874                                      10987654321098765432109876543210
4875                                      x1001011xx0xxxxxxxxxxxxxxxxxxxxx
4876                                      sub.  */
4877                                   return 24;
4878                                 }
4879                             }
4880                           else
4881                             {
4882                               if (((word >> 30) & 0x1) == 0)
4883                                 {
4884                                   /* 33222222222211111111110000000000
4885                                      10987654321098765432109876543210
4886                                      x0101011xx0xxxxxxxxxxxxxxxxxxxxx
4887                                      adds.  */
4888                                   return 22;
4889                                 }
4890                               else
4891                                 {
4892                                   /* 33222222222211111111110000000000
4893                                      10987654321098765432109876543210
4894                                      x1101011xx0xxxxxxxxxxxxxxxxxxxxx
4895                                      subs.  */
4896                                   return 26;
4897                                 }
4898                             }
4899                         }
4900                       else
4901                         {
4902                           if (((word >> 15) & 0x1) == 0)
4903                             {
4904                               if (((word >> 22) & 0x1) == 0)
4905                                 {
4906                                   /* 33222222222211111111110000000000
4907                                      10987654321098765432109876543210
4908                                      xxx11011x00xxxxx0xxxxxxxxxxxxxxx
4909                                      madd.  */
4910                                   return 735;
4911                                 }
4912                               else
4913                                 {
4914                                   if (((word >> 23) & 0x1) == 0)
4915                                     {
4916                                       /* 33222222222211111111110000000000
4917                                          10987654321098765432109876543210
4918                                          xxx11011010xxxxx0xxxxxxxxxxxxxxx
4919                                          smulh.  */
4920                                       return 743;
4921                                     }
4922                                   else
4923                                     {
4924                                       /* 33222222222211111111110000000000
4925                                          10987654321098765432109876543210
4926                                          xxx11011110xxxxx0xxxxxxxxxxxxxxx
4927                                          umulh.  */
4928                                       return 748;
4929                                     }
4930                                 }
4931                             }
4932                           else
4933                             {
4934                               /* 33222222222211111111110000000000
4935                                  10987654321098765432109876543210
4936                                  xxx11011xx0xxxxx1xxxxxxxxxxxxxxx
4937                                  msub.  */
4938                               return 737;
4939                             }
4940                         }
4941                     }
4942                   else
4943                     {
4944                       if (((word >> 23) & 0x1) == 0)
4945                         {
4946                           if (((word >> 28) & 0x1) == 0)
4947                             {
4948                               if (((word >> 29) & 0x1) == 0)
4949                                 {
4950                                   if (((word >> 30) & 0x1) == 0)
4951                                     {
4952                                       /* 33222222222211111111110000000000
4953                                          10987654321098765432109876543210
4954                                          x00010110x1xxxxxxxxxxxxxxxxxxxxx
4955                                          add.  */
4956                                       return 6;
4957                                     }
4958                                   else
4959                                     {
4960                                       /* 33222222222211111111110000000000
4961                                          10987654321098765432109876543210
4962                                          x10010110x1xxxxxxxxxxxxxxxxxxxxx
4963                                          sub.  */
4964                                       return 9;
4965                                     }
4966                                 }
4967                               else
4968                                 {
4969                                   if (((word >> 30) & 0x1) == 0)
4970                                     {
4971                                       /* 33222222222211111111110000000000
4972                                          10987654321098765432109876543210
4973                                          x01010110x1xxxxxxxxxxxxxxxxxxxxx
4974                                          adds.  */
4975                                       return 7;
4976                                     }
4977                                   else
4978                                     {
4979                                       /* 33222222222211111111110000000000
4980                                          10987654321098765432109876543210
4981                                          x11010110x1xxxxxxxxxxxxxxxxxxxxx
4982                                          subs.  */
4983                                       return 10;
4984                                     }
4985                                 }
4986                             }
4987                           else
4988                             {
4989                               if (((word >> 15) & 0x1) == 0)
4990                                 {
4991                                   /* 33222222222211111111110000000000
4992                                      10987654321098765432109876543210
4993                                      xxx110110x1xxxxx0xxxxxxxxxxxxxxx
4994                                      smaddl.  */
4995                                   return 739;
4996                                 }
4997                               else
4998                                 {
4999                                   /* 33222222222211111111110000000000
5000                                      10987654321098765432109876543210
5001                                      xxx110110x1xxxxx1xxxxxxxxxxxxxxx
5002                                      smsubl.  */
5003                                   return 741;
5004                                 }
5005                             }
5006                         }
5007                       else
5008                         {
5009                           if (((word >> 15) & 0x1) == 0)
5010                             {
5011                               /* 33222222222211111111110000000000
5012                                  10987654321098765432109876543210
5013                                  xxxx10111x1xxxxx0xxxxxxxxxxxxxxx
5014                                  umaddl.  */
5015                               return 744;
5016                             }
5017                           else
5018                             {
5019                               /* 33222222222211111111110000000000
5020                                  10987654321098765432109876543210
5021                                  xxxx10111x1xxxxx1xxxxxxxxxxxxxxx
5022                                  umsubl.  */
5023                               return 746;
5024                             }
5025                         }
5026                     }
5027                 }
5028             }
5029         }
5030     }
5031   else
5032     {
5033       if (((word >> 27) & 0x1) == 0)
5034         {
5035           if (((word >> 28) & 0x1) == 0)
5036             {
5037               if (((word >> 24) & 0x1) == 0)
5038                 {
5039                   if (((word >> 29) & 0x1) == 0)
5040                     {
5041                       if (((word >> 13) & 0x1) == 0)
5042                         {
5043                           if (((word >> 14) & 0x1) == 0)
5044                             {
5045                               if (((word >> 15) & 0x1) == 0)
5046                                 {
5047                                   if (((word >> 21) & 0x1) == 0)
5048                                     {
5049                                       if (((word >> 30) & 0x1) == 0)
5050                                         {
5051                                           if (((word >> 31) & 0x1) == 0)
5052                                             {
5053                                               if (((word >> 16) & 0x1) == 0)
5054                                                 {
5055                                                   if (((word >> 17) & 0x1) == 0)
5056                                                     {
5057                                                       if (((word >> 18) & 0x1) == 0)
5058                                                         {
5059                                                           if (((word >> 19) & 0x1) == 0)
5060                                                             {
5061                                                               if (((word >> 20) & 0x1) == 0)
5062                                                                 {
5063                                                                   /* 33222222222211111111110000000000
5064                                                                      10987654321098765432109876543210
5065                                                                      000001x0xx000000000xxxxxxxxxxxxx
5066                                                                      add.  */
5067                                                                   return 1292;
5068                                                                 }
5069                                                               else
5070                                                                 {
5071                                                                   /* 33222222222211111111110000000000
5072                                                                      10987654321098765432109876543210
5073                                                                      000001x0xx010000000xxxxxxxxxxxxx
5074                                                                      mul.  */
5075                                                                   return 1761;
5076                                                                 }
5077                                                             }
5078                                                           else
5079                                                             {
5080                                                               if (((word >> 20) & 0x1) == 0)
5081                                                                 {
5082                                                                   /* 33222222222211111111110000000000
5083                                                                      10987654321098765432109876543210
5084                                                                      000001x0xx001000000xxxxxxxxxxxxx
5085                                                                      smax.  */
5086                                                                   return 1840;
5087                                                                 }
5088                                                               else
5089                                                                 {
5090                                                                   /* 33222222222211111111110000000000
5091                                                                      10987654321098765432109876543210
5092                                                                      000001x0xx011000000xxxxxxxxxxxxx
5093                                                                      orr.  */
5094                                                                   return 1772;
5095                                                                 }
5096                                                             }
5097                                                         }
5098                                                       else
5099                                                         {
5100                                                           if (((word >> 19) & 0x1) == 0)
5101                                                             {
5102                                                               /* 33222222222211111111110000000000
5103                                                                  10987654321098765432109876543210
5104                                                                  000001x0xx0x0100000xxxxxxxxxxxxx
5105                                                                  sdiv.  */
5106                                                               return 1831;
5107                                                             }
5108                                                           else
5109                                                             {
5110                                                               /* 33222222222211111111110000000000
5111                                                                  10987654321098765432109876543210
5112                                                                  000001x0xx0x1100000xxxxxxxxxxxxx
5113                                                                  sabd.  */
5114                                                               return 1822;
5115                                                             }
5116                                                         }
5117                                                     }
5118                                                   else
5119                                                     {
5120                                                       if (((word >> 18) & 0x1) == 0)
5121                                                         {
5122                                                           if (((word >> 19) & 0x1) == 0)
5123                                                             {
5124                                                               /* 33222222222211111111110000000000
5125                                                                  10987654321098765432109876543210
5126                                                                  000001x0xx0x0010000xxxxxxxxxxxxx
5127                                                                  smulh.  */
5128                                                               return 1845;
5129                                                             }
5130                                                           else
5131                                                             {
5132                                                               if (((word >> 20) & 0x1) == 0)
5133                                                                 {
5134                                                                   /* 33222222222211111111110000000000
5135                                                                      10987654321098765432109876543210
5136                                                                      000001x0xx001010000xxxxxxxxxxxxx
5137                                                                      smin.  */
5138                                                                   return 1843;
5139                                                                 }
5140                                                               else
5141                                                                 {
5142                                                                   /* 33222222222211111111110000000000
5143                                                                      10987654321098765432109876543210
5144                                                                      000001x0xx011010000xxxxxxxxxxxxx
5145                                                                      and.  */
5146                                                                   return 1300;
5147                                                                 }
5148                                                             }
5149                                                         }
5150                                                       else
5151                                                         {
5152                                                           /* 33222222222211111111110000000000
5153                                                              10987654321098765432109876543210
5154                                                              000001x0xx0xx110000xxxxxxxxxxxxx
5155                                                              sdivr.  */
5156                                                           return 1832;
5157                                                         }
5158                                                     }
5159                                                 }
5160                                               else
5161                                                 {
5162                                                   if (((word >> 17) & 0x1) == 0)
5163                                                     {
5164                                                       if (((word >> 18) & 0x1) == 0)
5165                                                         {
5166                                                           if (((word >> 19) & 0x1) == 0)
5167                                                             {
5168                                                               /* 33222222222211111111110000000000
5169                                                                  10987654321098765432109876543210
5170                                                                  000001x0xx0x0001000xxxxxxxxxxxxx
5171                                                                  sub.  */
5172                                                               return 1961;
5173                                                             }
5174                                                           else
5175                                                             {
5176                                                               if (((word >> 20) & 0x1) == 0)
5177                                                                 {
5178                                                                   /* 33222222222211111111110000000000
5179                                                                      10987654321098765432109876543210
5180                                                                      000001x0xx001001000xxxxxxxxxxxxx
5181                                                                      umax.  */
5182                                                                   return 1989;
5183                                                                 }
5184                                                               else
5185                                                                 {
5186                                                                   /* 33222222222211111111110000000000
5187                                                                      10987654321098765432109876543210
5188                                                                      000001x0xx011001000xxxxxxxxxxxxx
5189                                                                      eor.  */
5190                                                                   return 1387;
5191                                                                 }
5192                                                             }
5193                                                         }
5194                                                       else
5195                                                         {
5196                                                           if (((word >> 19) & 0x1) == 0)
5197                                                             {
5198                                                               /* 33222222222211111111110000000000
5199                                                                  10987654321098765432109876543210
5200                                                                  000001x0xx0x0101000xxxxxxxxxxxxx
5201                                                                  udiv.  */
5202                                                               return 1983;
5203                                                             }
5204                                                           else
5205                                                             {
5206                                                               /* 33222222222211111111110000000000
5207                                                                  10987654321098765432109876543210
5208                                                                  000001x0xx0x1101000xxxxxxxxxxxxx
5209                                                                  uabd.  */
5210                                                               return 1974;
5211                                                             }
5212                                                         }
5213                                                     }
5214                                                   else
5215                                                     {
5216                                                       if (((word >> 18) & 0x1) == 0)
5217                                                         {
5218                                                           if (((word >> 19) & 0x1) == 0)
5219                                                             {
5220                                                               if (((word >> 20) & 0x1) == 0)
5221                                                                 {
5222                                                                   /* 33222222222211111111110000000000
5223                                                                      10987654321098765432109876543210
5224                                                                      000001x0xx000011000xxxxxxxxxxxxx
5225                                                                      subr.  */
5226                                                                   return 1963;
5227                                                                 }
5228                                                               else
5229                                                                 {
5230                                                                   /* 33222222222211111111110000000000
5231                                                                      10987654321098765432109876543210
5232                                                                      000001x0xx010011000xxxxxxxxxxxxx
5233                                                                      umulh.  */
5234                                                                   return 1994;
5235                                                                 }
5236                                                             }
5237                                                           else
5238                                                             {
5239                                                               if (((word >> 20) & 0x1) == 0)
5240                                                                 {
5241                                                                   /* 33222222222211111111110000000000
5242                                                                      10987654321098765432109876543210
5243                                                                      000001x0xx001011000xxxxxxxxxxxxx
5244                                                                      umin.  */
5245                                                                   return 1992;
5246                                                                 }
5247                                                               else
5248                                                                 {
5249                                                                   /* 33222222222211111111110000000000
5250                                                                      10987654321098765432109876543210
5251                                                                      000001x0xx011011000xxxxxxxxxxxxx
5252                                                                      bic.  */
5253                                                                   return 1312;
5254                                                                 }
5255                                                             }
5256                                                         }
5257                                                       else
5258                                                         {
5259                                                           /* 33222222222211111111110000000000
5260                                                              10987654321098765432109876543210
5261                                                              000001x0xx0xx111000xxxxxxxxxxxxx
5262                                                              udivr.  */
5263                                                           return 1984;
5264                                                         }
5265                                                     }
5266                                                 }
5267                                             }
5268                                           else
5269                                             {
5270                                               if (((word >> 23) & 0x1) == 0)
5271                                                 {
5272                                                   /* 33222222222211111111110000000000
5273                                                      10987654321098765432109876543210
5274                                                      100001x00x0xxxxx000xxxxxxxxxxxxx
5275                                                      ld1sb.  */
5276                                                   return 1574;
5277                                                 }
5278                                               else
5279                                                 {
5280                                                   /* 33222222222211111111110000000000
5281                                                      10987654321098765432109876543210
5282                                                      100001x01x0xxxxx000xxxxxxxxxxxxx
5283                                                      ld1sh.  */
5284                                                   return 1585;
5285                                                 }
5286                                             }
5287                                         }
5288                                       else
5289                                         {
5290                                           if (((word >> 31) & 0x1) == 0)
5291                                             {
5292                                               if (((word >> 12) & 0x1) == 0)
5293                                                 {
5294                                                   if (((word >> 10) & 0x1) == 0)
5295                                                     {
5296                                                       if (((word >> 11) & 0x1) == 0)
5297                                                         {
5298                                                           /* 33222222222211111111110000000000
5299                                                              10987654321098765432109876543210
5300                                                              010001x0xx0xxxxx000000xxxxxxxxxx
5301                                                              sdot.  */
5302                                                           return 1833;
5303                                                         }
5304                                                       else
5305                                                         {
5306                                                           /* 33222222222211111111110000000000
5307                                                              10987654321098765432109876543210
5308                                                              010001x0xx0xxxxx000010xxxxxxxxxx
5309                                                              sqdmlalbt.  */
5310                                                           return 2183;
5311                                                         }
5312                                                     }
5313                                                   else
5314                                                     {
5315                                                       if (((word >> 11) & 0x1) == 0)
5316                                                         {
5317                                                           /* 33222222222211111111110000000000
5318                                                              10987654321098765432109876543210
5319                                                              010001x0xx0xxxxx000001xxxxxxxxxx
5320                                                              udot.  */
5321                                                           return 1985;
5322                                                         }
5323                                                       else
5324                                                         {
5325                                                           /* 33222222222211111111110000000000
5326                                                              10987654321098765432109876543210
5327                                                              010001x0xx0xxxxx000011xxxxxxxxxx
5328                                                              sqdmlslbt.  */
5329                                                           return 2190;
5330                                                         }
5331                                                     }
5332                                                 }
5333                                               else
5334                                                 {
5335                                                   /* 33222222222211111111110000000000
5336                                                      10987654321098765432109876543210
5337                                                      010001x0xx0xxxxx0001xxxxxxxxxxxx
5338                                                      cdot.  */
5339                                                   return 2072;
5340                                                 }
5341                                             }
5342                                           else
5343                                             {
5344                                               if (((word >> 23) & 0x1) == 0)
5345                                                 {
5346                                                   /* 33222222222211111111110000000000
5347                                                      10987654321098765432109876543210
5348                                                      110001x00x0xxxxx000xxxxxxxxxxxxx
5349                                                      ld1sb.  */
5350                                                   return 1578;
5351                                                 }
5352                                               else
5353                                                 {
5354                                                   /* 33222222222211111111110000000000
5355                                                      10987654321098765432109876543210
5356                                                      110001x01x0xxxxx000xxxxxxxxxxxxx
5357                                                      ld1sh.  */
5358                                                   return 1589;
5359                                                 }
5360                                             }
5361                                         }
5362                                     }
5363                                   else
5364                                     {
5365                                       if (((word >> 30) & 0x1) == 0)
5366                                         {
5367                                           if (((word >> 31) & 0x1) == 0)
5368                                             {
5369                                               if (((word >> 10) & 0x1) == 0)
5370                                                 {
5371                                                   if (((word >> 11) & 0x1) == 0)
5372                                                     {
5373                                                       if (((word >> 12) & 0x1) == 0)
5374                                                         {
5375                                                           /* 33222222222211111111110000000000
5376                                                              10987654321098765432109876543210
5377                                                              000001x0xx1xxxxx000000xxxxxxxxxx
5378                                                              add.  */
5379                                                           return 1290;
5380                                                         }
5381                                                       else
5382                                                         {
5383                                                           /* 33222222222211111111110000000000
5384                                                              10987654321098765432109876543210
5385                                                              000001x0xx1xxxxx000100xxxxxxxxxx
5386                                                              sqadd.  */
5387                                                           return 1847;
5388                                                         }
5389                                                     }
5390                                                   else
5391                                                     {
5392                                                       /* 33222222222211111111110000000000
5393                                                          10987654321098765432109876543210
5394                                                          000001x0xx1xxxxx000x10xxxxxxxxxx
5395                                                          sqsub.  */
5396                                                       return 1877;
5397                                                     }
5398                                                 }
5399                                               else
5400                                                 {
5401                                                   if (((word >> 11) & 0x1) == 0)
5402                                                     {
5403                                                       if (((word >> 12) & 0x1) == 0)
5404                                                         {
5405                                                           /* 33222222222211111111110000000000
5406                                                              10987654321098765432109876543210
5407                                                              000001x0xx1xxxxx000001xxxxxxxxxx
5408                                                              sub.  */
5409                                                           return 1959;
5410                                                         }
5411                                                       else
5412                                                         {
5413                                                           /* 33222222222211111111110000000000
5414                                                              10987654321098765432109876543210
5415                                                              000001x0xx1xxxxx000101xxxxxxxxxx
5416                                                              uqadd.  */
5417                                                           return 1995;
5418                                                         }
5419                                                     }
5420                                                   else
5421                                                     {
5422                                                       /* 33222222222211111111110000000000
5423                                                          10987654321098765432109876543210
5424                                                          000001x0xx1xxxxx000x11xxxxxxxxxx
5425                                                          uqsub.  */
5426                                                       return 2025;
5427                                                     }
5428                                                 }
5429                                             }
5430                                           else
5431                                             {
5432                                               if (((word >> 23) & 0x1) == 0)
5433                                                 {
5434                                                   /* 33222222222211111111110000000000
5435                                                      10987654321098765432109876543210
5436                                                      100001x00x1xxxxx000xxxxxxxxxxxxx
5437                                                      prfb.  */
5438                                                   return 1780;
5439                                                 }
5440                                               else
5441                                                 {
5442                                                   /* 33222222222211111111110000000000
5443                                                      10987654321098765432109876543210
5444                                                      100001x01x1xxxxx000xxxxxxxxxxxxx
5445                                                      ld1sh.  */
5446                                                   return 1586;
5447                                                 }
5448                                             }
5449                                         }
5450                                       else
5451                                         {
5452                                           if (((word >> 23) & 0x1) == 0)
5453                                             {
5454                                               if (((word >> 31) & 0x1) == 0)
5455                                                 {
5456                                                   if (((word >> 10) & 0x1) == 0)
5457                                                     {
5458                                                       if (((word >> 11) & 0x1) == 0)
5459                                                         {
5460                                                           /* 33222222222211111111110000000000
5461                                                              10987654321098765432109876543210
5462                                                              010001x00x1xxxxx000x00xxxxxxxxxx
5463                                                              sqrdmlah.  */
5464                                                           return 2208;
5465                                                         }
5466                                                       else
5467                                                         {
5468                                                           /* 33222222222211111111110000000000
5469                                                              10987654321098765432109876543210
5470                                                              010001x00x1xxxxx000x10xxxxxxxxxx
5471                                                              mla.  */
5472                                                           return 2115;
5473                                                         }
5474                                                     }
5475                                                   else
5476                                                     {
5477                                                       if (((word >> 11) & 0x1) == 0)
5478                                                         {
5479                                                           /* 33222222222211111111110000000000
5480                                                              10987654321098765432109876543210
5481                                                              010001x00x1xxxxx000x01xxxxxxxxxx
5482                                                              sqrdmlsh.  */
5483                                                           return 2212;
5484                                                         }
5485                                                       else
5486                                                         {
5487                                                           /* 33222222222211111111110000000000
5488                                                              10987654321098765432109876543210
5489                                                              010001x00x1xxxxx000x11xxxxxxxxxx
5490                                                              mls.  */
5491                                                           return 2118;
5492                                                         }
5493                                                     }
5494                                                 }
5495                                               else
5496                                                 {
5497                                                   /* 33222222222211111111110000000000
5498                                                      10987654321098765432109876543210
5499                                                      110001x00x1xxxxx000xxxxxxxxxxxxx
5500                                                      prfb.  */
5501                                                   return 1781;
5502                                                 }
5503                                             }
5504                                           else
5505                                             {
5506                                               if (((word >> 31) & 0x1) == 0)
5507                                                 {
5508                                                   if (((word >> 10) & 0x1) == 0)
5509                                                     {
5510                                                       if (((word >> 11) & 0x1) == 0)
5511                                                         {
5512                                                           if (((word >> 12) & 0x1) == 0)
5513                                                             {
5514                                                               if (((word >> 22) & 0x1) == 0)
5515                                                                 {
5516                                                                   /* 33222222222211111111110000000000
5517                                                                      10987654321098765432109876543210
5518                                                                      010001x0101xxxxx000000xxxxxxxxxx
5519                                                                      sdot.  */
5520                                                                   return 1834;
5521                                                                 }
5522                                                               else
5523                                                                 {
5524                                                                   /* 33222222222211111111110000000000
5525                                                                      10987654321098765432109876543210
5526                                                                      010001x0111xxxxx000000xxxxxxxxxx
5527                                                                      sdot.  */
5528                                                                   return 1835;
5529                                                                 }
5530                                                             }
5531                                                           else
5532                                                             {
5533                                                               if (((word >> 22) & 0x1) == 0)
5534                                                                 {
5535                                                                   /* 33222222222211111111110000000000
5536                                                                      10987654321098765432109876543210
5537                                                                      010001x0101xxxxx000100xxxxxxxxxx
5538                                                                      sqrdmlah.  */
5539                                                                   return 2209;
5540                                                                 }
5541                                                               else
5542                                                                 {
5543                                                                   /* 33222222222211111111110000000000
5544                                                                      10987654321098765432109876543210
5545                                                                      010001x0111xxxxx000100xxxxxxxxxx
5546                                                                      sqrdmlah.  */
5547                                                                   return 2210;
5548                                                                 }
5549                                                             }
5550                                                         }
5551                                                       else
5552                                                         {
5553                                                           if (((word >> 12) & 0x1) == 0)
5554                                                             {
5555                                                               if (((word >> 22) & 0x1) == 0)
5556                                                                 {
5557                                                                   /* 33222222222211111111110000000000
5558                                                                      10987654321098765432109876543210
5559                                                                      010001x0101xxxxx000010xxxxxxxxxx
5560                                                                      mla.  */
5561                                                                   return 2116;
5562                                                                 }
5563                                                               else
5564                                                                 {
5565                                                                   /* 33222222222211111111110000000000
5566                                                                      10987654321098765432109876543210
5567                                                                      010001x0111xxxxx000010xxxxxxxxxx
5568                                                                      mla.  */
5569                                                                   return 2117;
5570                                                                 }
5571                                                             }
5572                                                           else
5573                                                             {
5574                                                               /* 33222222222211111111110000000000
5575                                                                  10987654321098765432109876543210
5576                                                                  010001x01x1xxxxx000110xxxxxxxxxx
5577                                                                  usdot.  */
5578                                                               return 2472;
5579                                                             }
5580                                                         }
5581                                                     }
5582                                                   else
5583                                                     {
5584                                                       if (((word >> 11) & 0x1) == 0)
5585                                                         {
5586                                                           if (((word >> 12) & 0x1) == 0)
5587                                                             {
5588                                                               if (((word >> 22) & 0x1) == 0)
5589                                                                 {
5590                                                                   /* 33222222222211111111110000000000
5591                                                                      10987654321098765432109876543210
5592                                                                      010001x0101xxxxx000001xxxxxxxxxx
5593                                                                      udot.  */
5594                                                                   return 1986;
5595                                                                 }
5596                                                               else
5597                                                                 {
5598                                                                   /* 33222222222211111111110000000000
5599                                                                      10987654321098765432109876543210
5600                                                                      010001x0111xxxxx000001xxxxxxxxxx
5601                                                                      udot.  */
5602                                                                   return 1987;
5603                                                                 }
5604                                                             }
5605                                                           else
5606                                                             {
5607                                                               if (((word >> 22) & 0x1) == 0)
5608                                                                 {
5609                                                                   /* 33222222222211111111110000000000
5610                                                                      10987654321098765432109876543210
5611                                                                      010001x0101xxxxx000101xxxxxxxxxx
5612                                                                      sqrdmlsh.  */
5613                                                                   return 2213;
5614                                                                 }
5615                                                               else
5616                                                                 {
5617                                                                   /* 33222222222211111111110000000000
5618                                                                      10987654321098765432109876543210
5619                                                                      010001x0111xxxxx000101xxxxxxxxxx
5620                                                                      sqrdmlsh.  */
5621                                                                   return 2214;
5622                                                                 }
5623                                                             }
5624                                                         }
5625                                                       else
5626                                                         {
5627                                                           if (((word >> 12) & 0x1) == 0)
5628                                                             {
5629                                                               if (((word >> 22) & 0x1) == 0)
5630                                                                 {
5631                                                                   /* 33222222222211111111110000000000
5632                                                                      10987654321098765432109876543210
5633                                                                      010001x0101xxxxx000011xxxxxxxxxx
5634                                                                      mls.  */
5635                                                                   return 2119;
5636                                                                 }
5637                                                               else
5638                                                                 {
5639                                                                   /* 33222222222211111111110000000000
5640                                                                      10987654321098765432109876543210
5641                                                                      010001x0111xxxxx000011xxxxxxxxxx
5642                                                                      mls.  */
5643                                                                   return 2120;
5644                                                                 }
5645                                                             }
5646                                                           else
5647                                                             {
5648                                                               /* 33222222222211111111110000000000
5649                                                                  10987654321098765432109876543210
5650                                                                  010001x01x1xxxxx000111xxxxxxxxxx
5651                                                                  sudot.  */
5652                                                               return 2473;
5653                                                             }
5654                                                         }
5655                                                     }
5656                                                 }
5657                                               else
5658                                                 {
5659                                                   /* 33222222222211111111110000000000
5660                                                      10987654321098765432109876543210
5661                                                      110001x01x1xxxxx000xxxxxxxxxxxxx
5662                                                      ld1sh.  */
5663                                                   return 1590;
5664                                                 }
5665                                             }
5666                                         }
5667                                     }
5668                                 }
5669                               else
5670                                 {
5671                                   if (((word >> 31) & 0x1) == 0)
5672                                     {
5673                                       if (((word >> 21) & 0x1) == 0)
5674                                         {
5675                                           if (((word >> 16) & 0x1) == 0)
5676                                             {
5677                                               if (((word >> 17) & 0x1) == 0)
5678                                                 {
5679                                                   if (((word >> 18) & 0x1) == 0)
5680                                                     {
5681                                                       if (((word >> 19) & 0x1) == 0)
5682                                                         {
5683                                                           if (((word >> 20) & 0x1) == 0)
5684                                                             {
5685                                                               /* 33222222222211111111110000000000
5686                                                                  10987654321098765432109876543210
5687                                                                  0x0001x0xx000000100xxxxxxxxxxxxx
5688                                                                  asr.  */
5689                                                               return 1308;
5690                                                             }
5691                                                           else
5692                                                             {
5693                                                               if (((word >> 30) & 0x1) == 0)
5694                                                                 {
5695                                                                   /* 33222222222211111111110000000000
5696                                                                      10987654321098765432109876543210
5697                                                                      000001x0xx010000100xxxxxxxxxxxxx
5698                                                                      asr.  */
5699                                                                   return 1306;
5700                                                                 }
5701                                                               else
5702                                                                 {
5703                                                                   /* 33222222222211111111110000000000
5704                                                                      10987654321098765432109876543210
5705                                                                      010001x0xx010000100xxxxxxxxxxxxx
5706                                                                      shadd.  */
5707                                                                   return 2149;
5708                                                                 }
5709                                                             }
5710                                                         }
5711                                                       else
5712                                                         {
5713                                                           if (((word >> 20) & 0x1) == 0)
5714                                                             {
5715                                                               /* 33222222222211111111110000000000
5716                                                                  10987654321098765432109876543210
5717                                                                  0x0001x0xx001000100xxxxxxxxxxxxx
5718                                                                  sqshl.  */
5719                                                               return 2227;
5720                                                             }
5721                                                           else
5722                                                             {
5723                                                               if (((word >> 30) & 0x1) == 0)
5724                                                                 {
5725                                                                   /* 33222222222211111111110000000000
5726                                                                      10987654321098765432109876543210
5727                                                                      000001x0xx011000100xxxxxxxxxxxxx
5728                                                                      asr.  */
5729                                                                   return 1307;
5730                                                                 }
5731                                                               else
5732                                                                 {
5733                                                                   /* 33222222222211111111110000000000
5734                                                                      10987654321098765432109876543210
5735                                                                      010001x0xx011000100xxxxxxxxxxxxx
5736                                                                      sqadd.  */
5737                                                                   return 2178;
5738                                                                 }
5739                                                             }
5740                                                         }
5741                                                     }
5742                                                   else
5743                                                     {
5744                                                       if (((word >> 19) & 0x1) == 0)
5745                                                         {
5746                                                           if (((word >> 20) & 0x1) == 0)
5747                                                             {
5748                                                               /* 33222222222211111111110000000000
5749                                                                  10987654321098765432109876543210
5750                                                                  0x0001x0xx000100100xxxxxxxxxxxxx
5751                                                                  asrd.  */
5752                                                               return 1309;
5753                                                             }
5754                                                           else
5755                                                             {
5756                                                               if (((word >> 30) & 0x1) == 0)
5757                                                                 {
5758                                                                   /* 33222222222211111111110000000000
5759                                                                      10987654321098765432109876543210
5760                                                                      000001x0xx010100100xxxxxxxxxxxxx
5761                                                                      asrr.  */
5762                                                                   return 1310;
5763                                                                 }
5764                                                               else
5765                                                                 {
5766                                                                   /* 33222222222211111111110000000000
5767                                                                      10987654321098765432109876543210
5768                                                                      010001x0xx010100100xxxxxxxxxxxxx
5769                                                                      srhadd.  */
5770                                                                   return 2240;
5771                                                                 }
5772                                                             }
5773                                                         }
5774                                                       else
5775                                                         {
5776                                                           if (((word >> 20) & 0x1) == 0)
5777                                                             {
5778                                                               if (((word >> 30) & 0x1) == 0)
5779                                                                 {
5780                                                                   /* 33222222222211111111110000000000
5781                                                                      10987654321098765432109876543210
5782                                                                      000001x0xx001100100xxxxxxxxxxxxx
5783                                                                      srshr.  */
5784                                                                   return 2244;
5785                                                                 }
5786                                                               else
5787                                                                 {
5788                                                                   /* 33222222222211111111110000000000
5789                                                                      10987654321098765432109876543210
5790                                                                      010001x0xx001100100xxxxxxxxxxxxx
5791                                                                      sqshlr.  */
5792                                                                   return 2228;
5793                                                                 }
5794                                                             }
5795                                                           else
5796                                                             {
5797                                                               /* 33222222222211111111110000000000
5798                                                                  10987654321098765432109876543210
5799                                                                  0x0001x0xx011100100xxxxxxxxxxxxx
5800                                                                  suqadd.  */
5801                                                               return 2264;
5802                                                             }
5803                                                         }
5804                                                     }
5805                                                 }
5806                                               else
5807                                                 {
5808                                                   if (((word >> 18) & 0x1) == 0)
5809                                                     {
5810                                                       if (((word >> 19) & 0x1) == 0)
5811                                                         {
5812                                                           if (((word >> 20) & 0x1) == 0)
5813                                                             {
5814                                                               /* 33222222222211111111110000000000
5815                                                                  10987654321098765432109876543210
5816                                                                  0x0001x0xx000010100xxxxxxxxxxxxx
5817                                                                  srshl.  */
5818                                                               return 2242;
5819                                                             }
5820                                                           else
5821                                                             {
5822                                                               /* 33222222222211111111110000000000
5823                                                                  10987654321098765432109876543210
5824                                                                  0x0001x0xx010010100xxxxxxxxxxxxx
5825                                                                  shsub.  */
5826                                                               return 2152;
5827                                                             }
5828                                                         }
5829                                                       else
5830                                                         {
5831                                                           if (((word >> 20) & 0x1) == 0)
5832                                                             {
5833                                                               /* 33222222222211111111110000000000
5834                                                                  10987654321098765432109876543210
5835                                                                  0x0001x0xx001010100xxxxxxxxxxxxx
5836                                                                  sqrshl.  */
5837                                                               return 2220;
5838                                                             }
5839                                                           else
5840                                                             {
5841                                                               /* 33222222222211111111110000000000
5842                                                                  10987654321098765432109876543210
5843                                                                  0x0001x0xx011010100xxxxxxxxxxxxx
5844                                                                  sqsub.  */
5845                                                               return 2234;
5846                                                             }
5847                                                         }
5848                                                     }
5849                                                   else
5850                                                     {
5851                                                       if (((word >> 19) & 0x1) == 0)
5852                                                         {
5853                                                           if (((word >> 20) & 0x1) == 0)
5854                                                             {
5855                                                               if (((word >> 30) & 0x1) == 0)
5856                                                                 {
5857                                                                   /* 33222222222211111111110000000000
5858                                                                      10987654321098765432109876543210
5859                                                                      000001x0xx000110100xxxxxxxxxxxxx
5860                                                                      sqshl.  */
5861                                                                   return 2226;
5862                                                                 }
5863                                                               else
5864                                                                 {
5865                                                                   /* 33222222222211111111110000000000
5866                                                                      10987654321098765432109876543210
5867                                                                      010001x0xx000110100xxxxxxxxxxxxx
5868                                                                      srshlr.  */
5869                                                                   return 2243;
5870                                                                 }
5871                                                             }
5872                                                           else
5873                                                             {
5874                                                               /* 33222222222211111111110000000000
5875                                                                  10987654321098765432109876543210
5876                                                                  0x0001x0xx010110100xxxxxxxxxxxxx
5877                                                                  shsubr.  */
5878                                                               return 2153;
5879                                                             }
5880                                                         }
5881                                                       else
5882                                                         {
5883                                                           if (((word >> 20) & 0x1) == 0)
5884                                                             {
5885                                                               /* 33222222222211111111110000000000
5886                                                                  10987654321098765432109876543210
5887                                                                  0x0001x0xx001110100xxxxxxxxxxxxx
5888                                                                  sqrshlr.  */
5889                                                               return 2221;
5890                                                             }
5891                                                           else
5892                                                             {
5893                                                               /* 33222222222211111111110000000000
5894                                                                  10987654321098765432109876543210
5895                                                                  0x0001x0xx011110100xxxxxxxxxxxxx
5896                                                                  sqsubr.  */
5897                                                               return 2235;
5898                                                             }
5899                                                         }
5900                                                     }
5901                                                 }
5902                                             }
5903                                           else
5904                                             {
5905                                               if (((word >> 17) & 0x1) == 0)
5906                                                 {
5907                                                   if (((word >> 18) & 0x1) == 0)
5908                                                     {
5909                                                       if (((word >> 19) & 0x1) == 0)
5910                                                         {
5911                                                           if (((word >> 20) & 0x1) == 0)
5912                                                             {
5913                                                               /* 33222222222211111111110000000000
5914                                                                  10987654321098765432109876543210
5915                                                                  0x0001x0xx000001100xxxxxxxxxxxxx
5916                                                                  lsr.  */
5917                                                               return 1752;
5918                                                             }
5919                                                           else
5920                                                             {
5921                                                               if (((word >> 30) & 0x1) == 0)
5922                                                                 {
5923                                                                   /* 33222222222211111111110000000000
5924                                                                      10987654321098765432109876543210
5925                                                                      000001x0xx010001100xxxxxxxxxxxxx
5926                                                                      lsr.  */
5927                                                                   return 1750;
5928                                                                 }
5929                                                               else
5930                                                                 {
5931                                                                   /* 33222222222211111111110000000000
5932                                                                      10987654321098765432109876543210
5933                                                                      010001x0xx010001100xxxxxxxxxxxxx
5934                                                                      uhadd.  */
5935                                                                   return 2277;
5936                                                                 }
5937                                                             }
5938                                                         }
5939                                                       else
5940                                                         {
5941                                                           if (((word >> 20) & 0x1) == 0)
5942                                                             {
5943                                                               /* 33222222222211111111110000000000
5944                                                                  10987654321098765432109876543210
5945                                                                  0x0001x0xx001001100xxxxxxxxxxxxx
5946                                                                  uqshl.  */
5947                                                               return 2307;
5948                                                             }
5949                                                           else
5950                                                             {
5951                                                               if (((word >> 30) & 0x1) == 0)
5952                                                                 {
5953                                                                   /* 33222222222211111111110000000000
5954                                                                      10987654321098765432109876543210
5955                                                                      000001x0xx011001100xxxxxxxxxxxxx
5956                                                                      lsr.  */
5957                                                                   return 1751;
5958                                                                 }
5959                                                               else
5960                                                                 {
5961                                                                   /* 33222222222211111111110000000000
5962                                                                      10987654321098765432109876543210
5963                                                                      010001x0xx011001100xxxxxxxxxxxxx
5964                                                                      uqadd.  */
5965                                                                   return 2301;
5966                                                                 }
5967                                                             }
5968                                                         }
5969                                                     }
5970                                                   else
5971                                                     {
5972                                                       if (((word >> 19) & 0x1) == 0)
5973                                                         {
5974                                                           if (((word >> 30) & 0x1) == 0)
5975                                                             {
5976                                                               /* 33222222222211111111110000000000
5977                                                                  10987654321098765432109876543210
5978                                                                  000001x0xx0x0101100xxxxxxxxxxxxx
5979                                                                  lsrr.  */
5980                                                               return 1753;
5981                                                             }
5982                                                           else
5983                                                             {
5984                                                               /* 33222222222211111111110000000000
5985                                                                  10987654321098765432109876543210
5986                                                                  010001x0xx0x0101100xxxxxxxxxxxxx
5987                                                                  urhadd.  */
5988                                                               return 2316;
5989                                                             }
5990                                                         }
5991                                                       else
5992                                                         {
5993                                                           if (((word >> 20) & 0x1) == 0)
5994                                                             {
5995                                                               if (((word >> 30) & 0x1) == 0)
5996                                                                 {
5997                                                                   /* 33222222222211111111110000000000
5998                                                                      10987654321098765432109876543210
5999                                                                      000001x0xx001101100xxxxxxxxxxxxx
6000                                                                      urshr.  */
6001                                                                   return 2319;
6002                                                                 }
6003                                                               else
6004                                                                 {
6005                                                                   /* 33222222222211111111110000000000
6006                                                                      10987654321098765432109876543210
6007                                                                      010001x0xx001101100xxxxxxxxxxxxx
6008                                                                      uqshlr.  */
6009                                                                   return 2308;
6010                                                                 }
6011                                                             }
6012                                                           else
6013                                                             {
6014                                                               /* 33222222222211111111110000000000
6015                                                                  10987654321098765432109876543210
6016                                                                  0x0001x0xx011101100xxxxxxxxxxxxx
6017                                                                  usqadd.  */
6018                                                               return 2324;
6019                                                             }
6020                                                         }
6021                                                     }
6022                                                 }
6023                                               else
6024                                                 {
6025                                                   if (((word >> 18) & 0x1) == 0)
6026                                                     {
6027                                                       if (((word >> 19) & 0x1) == 0)
6028                                                         {
6029                                                           if (((word >> 20) & 0x1) == 0)
6030                                                             {
6031                                                               if (((word >> 30) & 0x1) == 0)
6032                                                                 {
6033                                                                   /* 33222222222211111111110000000000
6034                                                                      10987654321098765432109876543210
6035                                                                      000001x0xx000011100xxxxxxxxxxxxx
6036                                                                      lsl.  */
6037                                                                   return 1746;
6038                                                                 }
6039                                                               else
6040                                                                 {
6041                                                                   /* 33222222222211111111110000000000
6042                                                                      10987654321098765432109876543210
6043                                                                      010001x0xx000011100xxxxxxxxxxxxx
6044                                                                      urshl.  */
6045                                                                   return 2317;
6046                                                                 }
6047                                                             }
6048                                                           else
6049                                                             {
6050                                                               if (((word >> 30) & 0x1) == 0)
6051                                                                 {
6052                                                                   /* 33222222222211111111110000000000
6053                                                                      10987654321098765432109876543210
6054                                                                      000001x0xx010011100xxxxxxxxxxxxx
6055                                                                      lsl.  */
6056                                                                   return 1744;
6057                                                                 }
6058                                                               else
6059                                                                 {
6060                                                                   /* 33222222222211111111110000000000
6061                                                                      10987654321098765432109876543210
6062                                                                      010001x0xx010011100xxxxxxxxxxxxx
6063                                                                      uhsub.  */
6064                                                                   return 2278;
6065                                                                 }
6066                                                             }
6067                                                         }
6068                                                       else
6069                                                         {
6070                                                           if (((word >> 20) & 0x1) == 0)
6071                                                             {
6072                                                               /* 33222222222211111111110000000000
6073                                                                  10987654321098765432109876543210
6074                                                                  0x0001x0xx001011100xxxxxxxxxxxxx
6075                                                                  uqrshl.  */
6076                                                               return 2302;
6077                                                             }
6078                                                           else
6079                                                             {
6080                                                               if (((word >> 30) & 0x1) == 0)
6081                                                                 {
6082                                                                   /* 33222222222211111111110000000000
6083                                                                      10987654321098765432109876543210
6084                                                                      000001x0xx011011100xxxxxxxxxxxxx
6085                                                                      lsl.  */
6086                                                                   return 1745;
6087                                                                 }
6088                                                               else
6089                                                                 {
6090                                                                   /* 33222222222211111111110000000000
6091                                                                      10987654321098765432109876543210
6092                                                                      010001x0xx011011100xxxxxxxxxxxxx
6093                                                                      uqsub.  */
6094                                                                   return 2311;
6095                                                                 }
6096                                                             }
6097                                                         }
6098                                                     }
6099                                                   else
6100                                                     {
6101                                                       if (((word >> 19) & 0x1) == 0)
6102                                                         {
6103                                                           if (((word >> 20) & 0x1) == 0)
6104                                                             {
6105                                                               if (((word >> 30) & 0x1) == 0)
6106                                                                 {
6107                                                                   /* 33222222222211111111110000000000
6108                                                                      10987654321098765432109876543210
6109                                                                      000001x0xx000111100xxxxxxxxxxxxx
6110                                                                      uqshl.  */
6111                                                                   return 2306;
6112                                                                 }
6113                                                               else
6114                                                                 {
6115                                                                   /* 33222222222211111111110000000000
6116                                                                      10987654321098765432109876543210
6117                                                                      010001x0xx000111100xxxxxxxxxxxxx
6118                                                                      urshlr.  */
6119                                                                   return 2318;
6120                                                                 }
6121                                                             }
6122                                                           else
6123                                                             {
6124                                                               if (((word >> 30) & 0x1) == 0)
6125                                                                 {
6126                                                                   /* 33222222222211111111110000000000
6127                                                                      10987654321098765432109876543210
6128                                                                      000001x0xx010111100xxxxxxxxxxxxx
6129                                                                      lslr.  */
6130                                                                   return 1747;
6131                                                                 }
6132                                                               else
6133                                                                 {
6134                                                                   /* 33222222222211111111110000000000
6135                                                                      10987654321098765432109876543210
6136                                                                      010001x0xx010111100xxxxxxxxxxxxx
6137                                                                      uhsubr.  */
6138                                                                   return 2279;
6139                                                                 }
6140                                                             }
6141                                                         }
6142                                                       else
6143                                                         {
6144                                                           if (((word >> 20) & 0x1) == 0)
6145                                                             {
6146                                                               if (((word >> 30) & 0x1) == 0)
6147                                                                 {
6148                                                                   /* 33222222222211111111110000000000
6149                                                                      10987654321098765432109876543210
6150                                                                      000001x0xx001111100xxxxxxxxxxxxx
6151                                                                      sqshlu.  */
6152                                                                   return 2229;
6153                                                                 }
6154                                                               else
6155                                                                 {
6156                                                                   /* 33222222222211111111110000000000
6157                                                                      10987654321098765432109876543210
6158                                                                      010001x0xx001111100xxxxxxxxxxxxx
6159                                                                      uqrshlr.  */
6160                                                                   return 2303;
6161                                                                 }
6162                                                             }
6163                                                           else
6164                                                             {
6165                                                               /* 33222222222211111111110000000000
6166                                                                  10987654321098765432109876543210
6167                                                                  0x0001x0xx011111100xxxxxxxxxxxxx
6168                                                                  uqsubr.  */
6169                                                               return 2312;
6170                                                             }
6171                                                         }
6172                                                     }
6173                                                 }
6174                                             }
6175                                         }
6176                                       else
6177                                         {
6178                                           if (((word >> 10) & 0x1) == 0)
6179                                             {
6180                                               if (((word >> 12) & 0x1) == 0)
6181                                                 {
6182                                                   if (((word >> 30) & 0x1) == 0)
6183                                                     {
6184                                                       /* 33222222222211111111110000000000
6185                                                          10987654321098765432109876543210
6186                                                          000001x0xx1xxxxx1000x0xxxxxxxxxx
6187                                                          asr.  */
6188                                                       return 1304;
6189                                                     }
6190                                                   else
6191                                                     {
6192                                                       if (((word >> 22) & 0x1) == 0)
6193                                                         {
6194                                                           /* 33222222222211111111110000000000
6195                                                              10987654321098765432109876543210
6196                                                              010001x0x01xxxxx1000x0xxxxxxxxxx
6197                                                              smlalb.  */
6198                                                           return 2157;
6199                                                         }
6200                                                       else
6201                                                         {
6202                                                           /* 33222222222211111111110000000000
6203                                                              10987654321098765432109876543210
6204                                                              010001x0x11xxxxx1000x0xxxxxxxxxx
6205                                                              smlalb.  */
6206                                                           return 2158;
6207                                                         }
6208                                                     }
6209                                                 }
6210                                               else
6211                                                 {
6212                                                   if (((word >> 30) & 0x1) == 0)
6213                                                     {
6214                                                       /* 33222222222211111111110000000000
6215                                                          10987654321098765432109876543210
6216                                                          000001x0xx1xxxxx1001x0xxxxxxxxxx
6217                                                          asr.  */
6218                                                       return 1305;
6219                                                     }
6220                                                   else
6221                                                     {
6222                                                       if (((word >> 22) & 0x1) == 0)
6223                                                         {
6224                                                           /* 33222222222211111111110000000000
6225                                                              10987654321098765432109876543210
6226                                                              010001x0x01xxxxx1001x0xxxxxxxxxx
6227                                                              umlalb.  */
6228                                                           return 2282;
6229                                                         }
6230                                                       else
6231                                                         {
6232                                                           /* 33222222222211111111110000000000
6233                                                              10987654321098765432109876543210
6234                                                              010001x0x11xxxxx1001x0xxxxxxxxxx
6235                                                              umlalb.  */
6236                                                           return 2283;
6237                                                         }
6238                                                     }
6239                                                 }
6240                                             }
6241                                           else
6242                                             {
6243                                               if (((word >> 12) & 0x1) == 0)
6244                                                 {
6245                                                   if (((word >> 30) & 0x1) == 0)
6246                                                     {
6247                                                       if (((word >> 11) & 0x1) == 0)
6248                                                         {
6249                                                           /* 33222222222211111111110000000000
6250                                                              10987654321098765432109876543210
6251                                                              000001x0xx1xxxxx100001xxxxxxxxxx
6252                                                              lsr.  */
6253                                                           return 1748;
6254                                                         }
6255                                                       else
6256                                                         {
6257                                                           /* 33222222222211111111110000000000
6258                                                              10987654321098765432109876543210
6259                                                              000001x0xx1xxxxx100011xxxxxxxxxx
6260                                                              lsl.  */
6261                                                           return 1742;
6262                                                         }
6263                                                     }
6264                                                   else
6265                                                     {
6266                                                       if (((word >> 22) & 0x1) == 0)
6267                                                         {
6268                                                           /* 33222222222211111111110000000000
6269                                                              10987654321098765432109876543210
6270                                                              010001x0x01xxxxx1000x1xxxxxxxxxx
6271                                                              smlalt.  */
6272                                                           return 2160;
6273                                                         }
6274                                                       else
6275                                                         {
6276                                                           /* 33222222222211111111110000000000
6277                                                              10987654321098765432109876543210
6278                                                              010001x0x11xxxxx1000x1xxxxxxxxxx
6279                                                              smlalt.  */
6280                                                           return 2161;
6281                                                         }
6282                                                     }
6283                                                 }
6284                                               else
6285                                                 {
6286                                                   if (((word >> 30) & 0x1) == 0)
6287                                                     {
6288                                                       if (((word >> 11) & 0x1) == 0)
6289                                                         {
6290                                                           /* 33222222222211111111110000000000
6291                                                              10987654321098765432109876543210
6292                                                              000001x0xx1xxxxx100101xxxxxxxxxx
6293                                                              lsr.  */
6294                                                           return 1749;
6295                                                         }
6296                                                       else
6297                                                         {
6298                                                           /* 33222222222211111111110000000000
6299                                                              10987654321098765432109876543210
6300                                                              000001x0xx1xxxxx100111xxxxxxxxxx
6301                                                              lsl.  */
6302                                                           return 1743;
6303                                                         }
6304                                                     }
6305                                                   else
6306                                                     {
6307                                                       if (((word >> 22) & 0x1) == 0)
6308                                                         {
6309                                                           /* 33222222222211111111110000000000
6310                                                              10987654321098765432109876543210
6311                                                              010001x0x01xxxxx1001x1xxxxxxxxxx
6312                                                              umlalt.  */
6313                                                           return 2285;
6314                                                         }
6315                                                       else
6316                                                         {
6317                                                           /* 33222222222211111111110000000000
6318                                                              10987654321098765432109876543210
6319                                                              010001x0x11xxxxx1001x1xxxxxxxxxx
6320                                                              umlalt.  */
6321                                                           return 2286;
6322                                                         }
6323                                                     }
6324                                                 }
6325                                             }
6326                                         }
6327                                     }
6328                                   else
6329                                     {
6330                                       if (((word >> 22) & 0x1) == 0)
6331                                         {
6332                                           if (((word >> 21) & 0x1) == 0)
6333                                             {
6334                                               if (((word >> 23) & 0x1) == 0)
6335                                                 {
6336                                                   /* 33222222222211111111110000000000
6337                                                      10987654321098765432109876543210
6338                                                      1x0001x0000xxxxx100xxxxxxxxxxxxx
6339                                                      ldnt1sb.  */
6340                                                   return 2109;
6341                                                 }
6342                                               else
6343                                                 {
6344                                                   /* 33222222222211111111110000000000
6345                                                      10987654321098765432109876543210
6346                                                      1x0001x0100xxxxx100xxxxxxxxxxxxx
6347                                                      ldnt1sh.  */
6348                                                   return 2110;
6349                                                 }
6350                                             }
6351                                           else
6352                                             {
6353                                               if (((word >> 23) & 0x1) == 0)
6354                                                 {
6355                                                   if (((word >> 30) & 0x1) == 0)
6356                                                     {
6357                                                       /* 33222222222211111111110000000000
6358                                                          10987654321098765432109876543210
6359                                                          100001x0001xxxxx100xxxxxxxxxxxxx
6360                                                          ld1sb.  */
6361                                                       return 1580;
6362                                                     }
6363                                                   else
6364                                                     {
6365                                                       /* 33222222222211111111110000000000
6366                                                          10987654321098765432109876543210
6367                                                          110001x0001xxxxx100xxxxxxxxxxxxx
6368                                                          ld1sb.  */
6369                                                       return 1584;
6370                                                     }
6371                                                 }
6372                                               else
6373                                                 {
6374                                                   if (((word >> 30) & 0x1) == 0)
6375                                                     {
6376                                                       /* 33222222222211111111110000000000
6377                                                          10987654321098765432109876543210
6378                                                          100001x0101xxxxx100xxxxxxxxxxxxx
6379                                                          ld1sh.  */
6380                                                       return 1593;
6381                                                     }
6382                                                   else
6383                                                     {
6384                                                       /* 33222222222211111111110000000000
6385                                                          10987654321098765432109876543210
6386                                                          110001x0101xxxxx100xxxxxxxxxxxxx
6387                                                          ld1sh.  */
6388                                                       return 1596;
6389                                                     }
6390                                                 }
6391                                             }
6392                                         }
6393                                       else
6394                                         {
6395                                           if (((word >> 23) & 0x1) == 0)
6396                                             {
6397                                               if (((word >> 30) & 0x1) == 0)
6398                                                 {
6399                                                   /* 33222222222211111111110000000000
6400                                                      10987654321098765432109876543210
6401                                                      100001x001xxxxxx100xxxxxxxxxxxxx
6402                                                      ld1rb.  */
6403                                                   return 1550;
6404                                                 }
6405                                               else
6406                                                 {
6407                                                   if (((word >> 21) & 0x1) == 0)
6408                                                     {
6409                                                       /* 33222222222211111111110000000000
6410                                                          10987654321098765432109876543210
6411                                                          110001x0010xxxxx100xxxxxxxxxxxxx
6412                                                          ld1sb.  */
6413                                                       return 1579;
6414                                                     }
6415                                                   else
6416                                                     {
6417                                                       /* 33222222222211111111110000000000
6418                                                          10987654321098765432109876543210
6419                                                          110001x0011xxxxx100xxxxxxxxxxxxx
6420                                                          prfb.  */
6421                                                       return 1782;
6422                                                     }
6423                                                 }
6424                                             }
6425                                           else
6426                                             {
6427                                               if (((word >> 30) & 0x1) == 0)
6428                                                 {
6429                                                   /* 33222222222211111111110000000000
6430                                                      10987654321098765432109876543210
6431                                                      100001x011xxxxxx100xxxxxxxxxxxxx
6432                                                      ld1rsw.  */
6433                                                   return 1571;
6434                                                 }
6435                                               else
6436                                                 {
6437                                                   if (((word >> 21) & 0x1) == 0)
6438                                                     {
6439                                                       /* 33222222222211111111110000000000
6440                                                          10987654321098765432109876543210
6441                                                          110001x0110xxxxx100xxxxxxxxxxxxx
6442                                                          ld1sh.  */
6443                                                       return 1591;
6444                                                     }
6445                                                   else
6446                                                     {
6447                                                       /* 33222222222211111111110000000000
6448                                                          10987654321098765432109876543210
6449                                                          110001x0111xxxxx100xxxxxxxxxxxxx
6450                                                          ld1sh.  */
6451                                                       return 1592;
6452                                                     }
6453                                                 }
6454                                             }
6455                                         }
6456                                     }
6457                                 }
6458                             }
6459                           else
6460                             {
6461                               if (((word >> 15) & 0x1) == 0)
6462                                 {
6463                                   if (((word >> 21) & 0x1) == 0)
6464                                     {
6465                                       if (((word >> 30) & 0x1) == 0)
6466                                         {
6467                                           if (((word >> 31) & 0x1) == 0)
6468                                             {
6469                                               /* 33222222222211111111110000000000
6470                                                  10987654321098765432109876543210
6471                                                  000001x0xx0xxxxx010xxxxxxxxxxxxx
6472                                                  mla.  */
6473                                               return 1755;
6474                                             }
6475                                           else
6476                                             {
6477                                               if (((word >> 23) & 0x1) == 0)
6478                                                 {
6479                                                   /* 33222222222211111111110000000000
6480                                                      10987654321098765432109876543210
6481                                                      100001x00x0xxxxx010xxxxxxxxxxxxx
6482                                                      ld1b.  */
6483                                                   return 1516;
6484                                                 }
6485                                               else
6486                                                 {
6487                                                   /* 33222222222211111111110000000000
6488                                                      10987654321098765432109876543210
6489                                                      100001x01x0xxxxx010xxxxxxxxxxxxx
6490                                                      ld1h.  */
6491                                                   return 1536;
6492                                                 }
6493                                             }
6494                                         }
6495                                       else
6496                                         {
6497                                           if (((word >> 31) & 0x1) == 0)
6498                                             {
6499                                               if (((word >> 10) & 0x1) == 0)
6500                                                 {
6501                                                   if (((word >> 11) & 0x1) == 0)
6502                                                     {
6503                                                       if (((word >> 12) & 0x1) == 0)
6504                                                         {
6505                                                           /* 33222222222211111111110000000000
6506                                                              10987654321098765432109876543210
6507                                                              010001x0xx0xxxxx010000xxxxxxxxxx
6508                                                              smlalb.  */
6509                                                           return 2159;
6510                                                         }
6511                                                       else
6512                                                         {
6513                                                           /* 33222222222211111111110000000000
6514                                                              10987654321098765432109876543210
6515                                                              010001x0xx0xxxxx010100xxxxxxxxxx
6516                                                              smlslb.  */
6517                                                           return 2165;
6518                                                         }
6519                                                     }
6520                                                   else
6521                                                     {
6522                                                       if (((word >> 12) & 0x1) == 0)
6523                                                         {
6524                                                           /* 33222222222211111111110000000000
6525                                                              10987654321098765432109876543210
6526                                                              010001x0xx0xxxxx010010xxxxxxxxxx
6527                                                              umlalb.  */
6528                                                           return 2284;
6529                                                         }
6530                                                       else
6531                                                         {
6532                                                           /* 33222222222211111111110000000000
6533                                                              10987654321098765432109876543210
6534                                                              010001x0xx0xxxxx010110xxxxxxxxxx
6535                                                              umlslb.  */
6536                                                           return 2290;
6537                                                         }
6538                                                     }
6539                                                 }
6540                                               else
6541                                                 {
6542                                                   if (((word >> 11) & 0x1) == 0)
6543                                                     {
6544                                                       if (((word >> 12) & 0x1) == 0)
6545                                                         {
6546                                                           /* 33222222222211111111110000000000
6547                                                              10987654321098765432109876543210
6548                                                              010001x0xx0xxxxx010001xxxxxxxxxx
6549                                                              smlalt.  */
6550                                                           return 2162;
6551                                                         }
6552                                                       else
6553                                                         {
6554                                                           /* 33222222222211111111110000000000
6555                                                              10987654321098765432109876543210
6556                                                              010001x0xx0xxxxx010101xxxxxxxxxx
6557                                                              smlslt.  */
6558                                                           return 2168;
6559                                                         }
6560                                                     }
6561                                                   else
6562                                                     {
6563                                                       if (((word >> 12) & 0x1) == 0)
6564                                                         {
6565                                                           /* 33222222222211111111110000000000
6566                                                              10987654321098765432109876543210
6567                                                              010001x0xx0xxxxx010011xxxxxxxxxx
6568                                                              umlalt.  */
6569                                                           return 2287;
6570                                                         }
6571                                                       else
6572                                                         {
6573                                                           /* 33222222222211111111110000000000
6574                                                              10987654321098765432109876543210
6575                                                              010001x0xx0xxxxx010111xxxxxxxxxx
6576                                                              umlslt.  */
6577                                                           return 2293;
6578                                                         }
6579                                                     }
6580                                                 }
6581                                             }
6582                                           else
6583                                             {
6584                                               if (((word >> 23) & 0x1) == 0)
6585                                                 {
6586                                                   /* 33222222222211111111110000000000
6587                                                      10987654321098765432109876543210
6588                                                      110001x00x0xxxxx010xxxxxxxxxxxxx
6589                                                      ld1b.  */
6590                                                   return 1521;
6591                                                 }
6592                                               else
6593                                                 {
6594                                                   /* 33222222222211111111110000000000
6595                                                      10987654321098765432109876543210
6596                                                      110001x01x0xxxxx010xxxxxxxxxxxxx
6597                                                      ld1h.  */
6598                                                   return 1541;
6599                                                 }
6600                                             }
6601                                         }
6602                                     }
6603                                   else
6604                                     {
6605                                       if (((word >> 30) & 0x1) == 0)
6606                                         {
6607                                           if (((word >> 31) & 0x1) == 0)
6608                                             {
6609                                               if (((word >> 11) & 0x1) == 0)
6610                                                 {
6611                                                   if (((word >> 12) & 0x1) == 0)
6612                                                     {
6613                                                       if (((word >> 10) & 0x1) == 0)
6614                                                         {
6615                                                           /* 33222222222211111111110000000000
6616                                                              10987654321098765432109876543210
6617                                                              000001x0xx1xxxxx010000xxxxxxxxxx
6618                                                              index.  */
6619                                                           return 1507;
6620                                                         }
6621                                                       else
6622                                                         {
6623                                                           /* 33222222222211111111110000000000
6624                                                              10987654321098765432109876543210
6625                                                              000001x0xx1xxxxx010001xxxxxxxxxx
6626                                                              index.  */
6627                                                           return 1508;
6628                                                         }
6629                                                     }
6630                                                   else
6631                                                     {
6632                                                       if (((word >> 22) & 0x1) == 0)
6633                                                         {
6634                                                           if (((word >> 23) & 0x1) == 0)
6635                                                             {
6636                                                               /* 33222222222211111111110000000000
6637                                                                  10987654321098765432109876543210
6638                                                                  000001x0001xxxxx01010xxxxxxxxxxx
6639                                                                  addvl.  */
6640                                                               return 1294;
6641                                                             }
6642                                                           else
6643                                                             {
6644                                                               /* 33222222222211111111110000000000
6645                                                                  10987654321098765432109876543210
6646                                                                  000001x0101xxxxx01010xxxxxxxxxxx
6647                                                                  rdvl.  */
6648                                                               return 1816;
6649                                                             }
6650                                                         }
6651                                                       else
6652                                                         {
6653                                                           /* 33222222222211111111110000000000
6654                                                              10987654321098765432109876543210
6655                                                              000001x0x11xxxxx01010xxxxxxxxxxx
6656                                                              addpl.  */
6657                                                           return 1293;
6658                                                         }
6659                                                     }
6660                                                 }
6661                                               else
6662                                                 {
6663                                                   if (((word >> 12) & 0x1) == 0)
6664                                                     {
6665                                                       if (((word >> 10) & 0x1) == 0)
6666                                                         {
6667                                                           /* 33222222222211111111110000000000
6668                                                              10987654321098765432109876543210
6669                                                              000001x0xx1xxxxx010010xxxxxxxxxx
6670                                                              index.  */
6671                                                           return 1509;
6672                                                         }
6673                                                       else
6674                                                         {
6675                                                           /* 33222222222211111111110000000000
6676                                                              10987654321098765432109876543210
6677                                                              000001x0xx1xxxxx010011xxxxxxxxxx
6678                                                              index.  */
6679                                                           return 1506;
6680                                                         }
6681                                                     }
6682                                                   else
6683                                                     {
6684                                                       if (((word >> 22) & 0x1) == 0)
6685                                                         {
6686                                                           if (((word >> 23) & 0x1) == 0)
6687                                                             {
6688                                                               /* 33222222222211111111110000000000
6689                                                                  10987654321098765432109876543210
6690                                                                  000001x0001xxxxx01011xxxxxxxxxxx
6691                                                                  addsvl.  */
6692                                                               return 2356;
6693                                                             }
6694                                                           else
6695                                                             {
6696                                                               /* 33222222222211111111110000000000
6697                                                                  10987654321098765432109876543210
6698                                                                  000001x0101xxxxx01011xxxxxxxxxxx
6699                                                                  rdsvl.  */
6700                                                               return 2367;
6701                                                             }
6702                                                         }
6703                                                       else
6704                                                         {
6705                                                           /* 33222222222211111111110000000000
6706                                                              10987654321098765432109876543210
6707                                                              000001x0x11xxxxx01011xxxxxxxxxxx
6708                                                              addspl.  */
6709                                                           return 2355;
6710                                                         }
6711                                                     }
6712                                                 }
6713                                             }
6714                                           else
6715                                             {
6716                                               if (((word >> 23) & 0x1) == 0)
6717                                                 {
6718                                                   /* 33222222222211111111110000000000
6719                                                      10987654321098765432109876543210
6720                                                      100001x00x1xxxxx010xxxxxxxxxxxxx
6721                                                      prfw.  */
6722                                                   return 1800;
6723                                                 }
6724                                               else
6725                                                 {
6726                                                   /* 33222222222211111111110000000000
6727                                                      10987654321098765432109876543210
6728                                                      100001x01x1xxxxx010xxxxxxxxxxxxx
6729                                                      ld1h.  */
6730                                                   return 1537;
6731                                                 }
6732                                             }
6733                                         }
6734                                       else
6735                                         {
6736                                           if (((word >> 23) & 0x1) == 0)
6737                                             {
6738                                               /* 33222222222211111111110000000000
6739                                                  10987654321098765432109876543210
6740                                                  x10001x00x1xxxxx010xxxxxxxxxxxxx
6741                                                  prfw.  */
6742                                               return 1802;
6743                                             }
6744                                           else
6745                                             {
6746                                               if (((word >> 31) & 0x1) == 0)
6747                                                 {
6748                                                   if (((word >> 22) & 0x1) == 0)
6749                                                     {
6750                                                       /* 33222222222211111111110000000000
6751                                                          10987654321098765432109876543210
6752                                                          010001x0101xxxxx010xxxxxxxxxxxxx
6753                                                          cdot.  */
6754                                                       return 2074;
6755                                                     }
6756                                                   else
6757                                                     {
6758                                                       /* 33222222222211111111110000000000
6759                                                          10987654321098765432109876543210
6760                                                          010001x0111xxxxx010xxxxxxxxxxxxx
6761                                                          cdot.  */
6762                                                       return 2073;
6763                                                     }
6764                                                 }
6765                                               else
6766                                                 {
6767                                                   /* 33222222222211111111110000000000
6768                                                      10987654321098765432109876543210
6769                                                      110001x01x1xxxxx010xxxxxxxxxxxxx
6770                                                      ld1h.  */
6771                                                   return 1542;
6772                                                 }
6773                                             }
6774                                         }
6775                                     }
6776                                 }
6777                               else
6778                                 {
6779                                   if (((word >> 30) & 0x1) == 0)
6780                                     {
6781                                       if (((word >> 31) & 0x1) == 0)
6782                                         {
6783                                           if (((word >> 21) & 0x1) == 0)
6784                                             {
6785                                               /* 33222222222211111111110000000000
6786                                                  10987654321098765432109876543210
6787                                                  000001x0xx0xxxxx110xxxxxxxxxxxxx
6788                                                  mad.  */
6789                                               return 1754;
6790                                             }
6791                                           else
6792                                             {
6793                                               if (((word >> 10) & 0x1) == 0)
6794                                                 {
6795                                                   if (((word >> 11) & 0x1) == 0)
6796                                                     {
6797                                                       if (((word >> 20) & 0x1) == 0)
6798                                                         {
6799                                                           if (((word >> 22) & 0x1) == 0)
6800                                                             {
6801                                                               /* 33222222222211111111110000000000
6802                                                                  10987654321098765432109876543210
6803                                                                  000001x0x010xxxx110x00xxxxxxxxxx
6804                                                                  sqincw.  */
6805                                                               return 1874;
6806                                                             }
6807                                                           else
6808                                                             {
6809                                                               if (((word >> 23) & 0x1) == 0)
6810                                                                 {
6811                                                                   /* 33222222222211111111110000000000
6812                                                                      10987654321098765432109876543210
6813                                                                      000001x00110xxxx110x00xxxxxxxxxx
6814                                                                      sqinch.  */
6815                                                                   return 1868;
6816                                                                 }
6817                                                               else
6818                                                                 {
6819                                                                   /* 33222222222211111111110000000000
6820                                                                      10987654321098765432109876543210
6821                                                                      000001x01110xxxx110x00xxxxxxxxxx
6822                                                                      sqincd.  */
6823                                                                   return 1865;
6824                                                                 }
6825                                                             }
6826                                                         }
6827                                                       else
6828                                                         {
6829                                                           if (((word >> 22) & 0x1) == 0)
6830                                                             {
6831                                                               /* 33222222222211111111110000000000
6832                                                                  10987654321098765432109876543210
6833                                                                  000001x0x011xxxx110x00xxxxxxxxxx
6834                                                                  incw.  */
6835                                                               return 1504;
6836                                                             }
6837                                                           else
6838                                                             {
6839                                                               if (((word >> 23) & 0x1) == 0)
6840                                                                 {
6841                                                                   /* 33222222222211111111110000000000
6842                                                                      10987654321098765432109876543210
6843                                                                      000001x00111xxxx110x00xxxxxxxxxx
6844                                                                      inch.  */
6845                                                                   return 1500;
6846                                                                 }
6847                                                               else
6848                                                                 {
6849                                                                   /* 33222222222211111111110000000000
6850                                                                      10987654321098765432109876543210
6851                                                                      000001x01111xxxx110x00xxxxxxxxxx
6852                                                                      incd.  */
6853                                                                   return 1498;
6854                                                                 }
6855                                                             }
6856                                                         }
6857                                                     }
6858                                                   else
6859                                                     {
6860                                                       if (((word >> 22) & 0x1) == 0)
6861                                                         {
6862                                                           /* 33222222222211111111110000000000
6863                                                              10987654321098765432109876543210
6864                                                              000001x0x01xxxxx110x10xxxxxxxxxx
6865                                                              sqdecw.  */
6866                                                           return 1860;
6867                                                         }
6868                                                       else
6869                                                         {
6870                                                           if (((word >> 23) & 0x1) == 0)
6871                                                             {
6872                                                               /* 33222222222211111111110000000000
6873                                                                  10987654321098765432109876543210
6874                                                                  000001x0011xxxxx110x10xxxxxxxxxx
6875                                                                  sqdech.  */
6876                                                               return 1854;
6877                                                             }
6878                                                           else
6879                                                             {
6880                                                               /* 33222222222211111111110000000000
6881                                                                  10987654321098765432109876543210
6882                                                                  000001x0111xxxxx110x10xxxxxxxxxx
6883                                                                  sqdecd.  */
6884                                                               return 1851;
6885                                                             }
6886                                                         }
6887                                                     }
6888                                                 }
6889                                               else
6890                                                 {
6891                                                   if (((word >> 11) & 0x1) == 0)
6892                                                     {
6893                                                       if (((word >> 20) & 0x1) == 0)
6894                                                         {
6895                                                           if (((word >> 22) & 0x1) == 0)
6896                                                             {
6897                                                               /* 33222222222211111111110000000000
6898                                                                  10987654321098765432109876543210
6899                                                                  000001x0x010xxxx110x01xxxxxxxxxx
6900                                                                  uqincw.  */
6901                                                               return 2022;
6902                                                             }
6903                                                           else
6904                                                             {
6905                                                               if (((word >> 23) & 0x1) == 0)
6906                                                                 {
6907                                                                   /* 33222222222211111111110000000000
6908                                                                      10987654321098765432109876543210
6909                                                                      000001x00110xxxx110x01xxxxxxxxxx
6910                                                                      uqinch.  */
6911                                                                   return 2016;
6912                                                                 }
6913                                                               else
6914                                                                 {
6915                                                                   /* 33222222222211111111110000000000
6916                                                                      10987654321098765432109876543210
6917                                                                      000001x01110xxxx110x01xxxxxxxxxx
6918                                                                      uqincd.  */
6919                                                                   return 2013;
6920                                                                 }
6921                                                             }
6922                                                         }
6923                                                       else
6924                                                         {
6925                                                           if (((word >> 22) & 0x1) == 0)
6926                                                             {
6927                                                               /* 33222222222211111111110000000000
6928                                                                  10987654321098765432109876543210
6929                                                                  000001x0x011xxxx110x01xxxxxxxxxx
6930                                                                  decw.  */
6931                                                               return 1379;
6932                                                             }
6933                                                           else
6934                                                             {
6935                                                               if (((word >> 23) & 0x1) == 0)
6936                                                                 {
6937                                                                   /* 33222222222211111111110000000000
6938                                                                      10987654321098765432109876543210
6939                                                                      000001x00111xxxx110x01xxxxxxxxxx
6940                                                                      dech.  */
6941                                                                   return 1375;
6942                                                                 }
6943                                                               else
6944                                                                 {
6945                                                                   /* 33222222222211111111110000000000
6946                                                                      10987654321098765432109876543210
6947                                                                      000001x01111xxxx110x01xxxxxxxxxx
6948                                                                      decd.  */
6949                                                                   return 1373;
6950                                                                 }
6951                                                             }
6952                                                         }
6953                                                     }
6954                                                   else
6955                                                     {
6956                                                       if (((word >> 22) & 0x1) == 0)
6957                                                         {
6958                                                           /* 33222222222211111111110000000000
6959                                                              10987654321098765432109876543210
6960                                                              000001x0x01xxxxx110x11xxxxxxxxxx
6961                                                              uqdecw.  */
6962                                                           return 2008;
6963                                                         }
6964                                                       else
6965                                                         {
6966                                                           if (((word >> 23) & 0x1) == 0)
6967                                                             {
6968                                                               /* 33222222222211111111110000000000
6969                                                                  10987654321098765432109876543210
6970                                                                  000001x0011xxxxx110x11xxxxxxxxxx
6971                                                                  uqdech.  */
6972                                                               return 2002;
6973                                                             }
6974                                                           else
6975                                                             {
6976                                                               /* 33222222222211111111110000000000
6977                                                                  10987654321098765432109876543210
6978                                                                  000001x0111xxxxx110x11xxxxxxxxxx
6979                                                                  uqdecd.  */
6980                                                               return 1999;
6981                                                             }
6982                                                         }
6983                                                     }
6984                                                 }
6985                                             }
6986                                         }
6987                                       else
6988                                         {
6989                                           if (((word >> 22) & 0x1) == 0)
6990                                             {
6991                                               if (((word >> 21) & 0x1) == 0)
6992                                                 {
6993                                                   if (((word >> 23) & 0x1) == 0)
6994                                                     {
6995                                                       /* 33222222222211111111110000000000
6996                                                          10987654321098765432109876543210
6997                                                          100001x0000xxxxx110xxxxxxxxxxxxx
6998                                                          prfb.  */
6999                                                       return 1779;
7000                                                     }
7001                                                   else
7002                                                     {
7003                                                       /* 33222222222211111111110000000000
7004                                                          10987654321098765432109876543210
7005                                                          100001x0100xxxxx110xxxxxxxxxxxxx
7006                                                          prfh.  */
7007                                                       return 1794;
7008                                                     }
7009                                                 }
7010                                               else
7011                                                 {
7012                                                   if (((word >> 23) & 0x1) == 0)
7013                                                     {
7014                                                       /* 33222222222211111111110000000000
7015                                                          10987654321098765432109876543210
7016                                                          100001x0001xxxxx110xxxxxxxxxxxxx
7017                                                          ld1b.  */
7018                                                       return 1523;
7019                                                     }
7020                                                   else
7021                                                     {
7022                                                       /* 33222222222211111111110000000000
7023                                                          10987654321098765432109876543210
7024                                                          100001x0101xxxxx110xxxxxxxxxxxxx
7025                                                          ld1h.  */
7026                                                       return 1545;
7027                                                     }
7028                                                 }
7029                                             }
7030                                           else
7031                                             {
7032                                               if (((word >> 23) & 0x1) == 0)
7033                                                 {
7034                                                   /* 33222222222211111111110000000000
7035                                                      10987654321098765432109876543210
7036                                                      100001x001xxxxxx110xxxxxxxxxxxxx
7037                                                      ld1rb.  */
7038                                                   return 1552;
7039                                                 }
7040                                               else
7041                                                 {
7042                                                   /* 33222222222211111111110000000000
7043                                                      10987654321098765432109876543210
7044                                                      100001x011xxxxxx110xxxxxxxxxxxxx
7045                                                      ld1rh.  */
7046                                                   return 1556;
7047                                                 }
7048                                             }
7049                                         }
7050                                     }
7051                                   else
7052                                     {
7053                                       if (((word >> 21) & 0x1) == 0)
7054                                         {
7055                                           if (((word >> 31) & 0x1) == 0)
7056                                             {
7057                                               if (((word >> 10) & 0x1) == 0)
7058                                                 {
7059                                                   /* 33222222222211111111110000000000
7060                                                      10987654321098765432109876543210
7061                                                      010001x0xx0xxxxx110xx0xxxxxxxxxx
7062                                                      sclamp.  */
7063                                                   return 2412;
7064                                                 }
7065                                               else
7066                                                 {
7067                                                   /* 33222222222211111111110000000000
7068                                                      10987654321098765432109876543210
7069                                                      010001x0xx0xxxxx110xx1xxxxxxxxxx
7070                                                      uclamp.  */
7071                                                   return 2413;
7072                                                 }
7073                                             }
7074                                           else
7075                                             {
7076                                               if (((word >> 22) & 0x1) == 0)
7077                                                 {
7078                                                   if (((word >> 23) & 0x1) == 0)
7079                                                     {
7080                                                       /* 33222222222211111111110000000000
7081                                                          10987654321098765432109876543210
7082                                                          110001x0000xxxxx110xxxxxxxxxxxxx
7083                                                          ldnt1b.  */
7084                                                       return 2105;
7085                                                     }
7086                                                   else
7087                                                     {
7088                                                       /* 33222222222211111111110000000000
7089                                                          10987654321098765432109876543210
7090                                                          110001x0100xxxxx110xxxxxxxxxxxxx
7091                                                          ldnt1h.  */
7092                                                       return 2108;
7093                                                     }
7094                                                 }
7095                                               else
7096                                                 {
7097                                                   if (((word >> 23) & 0x1) == 0)
7098                                                     {
7099                                                       /* 33222222222211111111110000000000
7100                                                          10987654321098765432109876543210
7101                                                          110001x0010xxxxx110xxxxxxxxxxxxx
7102                                                          ld1b.  */
7103                                                       return 1522;
7104                                                     }
7105                                                   else
7106                                                     {
7107                                                       /* 33222222222211111111110000000000
7108                                                          10987654321098765432109876543210
7109                                                          110001x0110xxxxx110xxxxxxxxxxxxx
7110                                                          ld1h.  */
7111                                                       return 1543;
7112                                                     }
7113                                                 }
7114                                             }
7115                                         }
7116                                       else
7117                                         {
7118                                           if (((word >> 22) & 0x1) == 0)
7119                                             {
7120                                               if (((word >> 23) & 0x1) == 0)
7121                                                 {
7122                                                   /* 33222222222211111111110000000000
7123                                                      10987654321098765432109876543210
7124                                                      x10001x0001xxxxx110xxxxxxxxxxxxx
7125                                                      ld1b.  */
7126                                                   return 1528;
7127                                                 }
7128                                               else
7129                                                 {
7130                                                   if (((word >> 31) & 0x1) == 0)
7131                                                     {
7132                                                       if (((word >> 10) & 0x1) == 0)
7133                                                         {
7134                                                           if (((word >> 12) & 0x1) == 0)
7135                                                             {
7136                                                               /* 33222222222211111111110000000000
7137                                                                  10987654321098765432109876543210
7138                                                                  010001x0101xxxxx1100x0xxxxxxxxxx
7139                                                                  smullb.  */
7140                                                               return 2170;
7141                                                             }
7142                                                           else
7143                                                             {
7144                                                               /* 33222222222211111111110000000000
7145                                                                  10987654321098765432109876543210
7146                                                                  010001x0101xxxxx1101x0xxxxxxxxxx
7147                                                                  umullb.  */
7148                                                               return 2295;
7149                                                             }
7150                                                         }
7151                                                       else
7152                                                         {
7153                                                           if (((word >> 12) & 0x1) == 0)
7154                                                             {
7155                                                               /* 33222222222211111111110000000000
7156                                                                  10987654321098765432109876543210
7157                                                                  010001x0101xxxxx1100x1xxxxxxxxxx
7158                                                                  smullt.  */
7159                                                               return 2173;
7160                                                             }
7161                                                           else
7162                                                             {
7163                                                               /* 33222222222211111111110000000000
7164                                                                  10987654321098765432109876543210
7165                                                                  010001x0101xxxxx1101x1xxxxxxxxxx
7166                                                                  umullt.  */
7167                                                               return 2298;
7168                                                             }
7169                                                         }
7170                                                     }
7171                                                   else
7172                                                     {
7173                                                       /* 33222222222211111111110000000000
7174                                                          10987654321098765432109876543210
7175                                                          110001x0101xxxxx110xxxxxxxxxxxxx
7176                                                          ld1h.  */
7177                                                       return 1549;
7178                                                     }
7179                                                 }
7180                                             }
7181                                           else
7182                                             {
7183                                               if (((word >> 23) & 0x1) == 0)
7184                                                 {
7185                                                   /* 33222222222211111111110000000000
7186                                                      10987654321098765432109876543210
7187                                                      x10001x0011xxxxx110xxxxxxxxxxxxx
7188                                                      prfw.  */
7189                                                   return 1803;
7190                                                 }
7191                                               else
7192                                                 {
7193                                                   if (((word >> 31) & 0x1) == 0)
7194                                                     {
7195                                                       if (((word >> 10) & 0x1) == 0)
7196                                                         {
7197                                                           if (((word >> 12) & 0x1) == 0)
7198                                                             {
7199                                                               /* 33222222222211111111110000000000
7200                                                                  10987654321098765432109876543210
7201                                                                  010001x0111xxxxx1100x0xxxxxxxxxx
7202                                                                  smullb.  */
7203                                                               return 2171;
7204                                                             }
7205                                                           else
7206                                                             {
7207                                                               /* 33222222222211111111110000000000
7208                                                                  10987654321098765432109876543210
7209                                                                  010001x0111xxxxx1101x0xxxxxxxxxx
7210                                                                  umullb.  */
7211                                                               return 2296;
7212                                                             }
7213                                                         }
7214                                                       else
7215                                                         {
7216                                                           if (((word >> 12) & 0x1) == 0)
7217                                                             {
7218                                                               /* 33222222222211111111110000000000
7219                                                                  10987654321098765432109876543210
7220                                                                  010001x0111xxxxx1100x1xxxxxxxxxx
7221                                                                  smullt.  */
7222                                                               return 2174;
7223                                                             }
7224                                                           else
7225                                                             {
7226                                                               /* 33222222222211111111110000000000
7227                                                                  10987654321098765432109876543210
7228                                                                  010001x0111xxxxx1101x1xxxxxxxxxx
7229                                                                  umullt.  */
7230                                                               return 2299;
7231                                                             }
7232                                                         }
7233                                                     }
7234                                                   else
7235                                                     {
7236                                                       /* 33222222222211111111110000000000
7237                                                          10987654321098765432109876543210
7238                                                          110001x0111xxxxx110xxxxxxxxxxxxx
7239                                                          ld1h.  */
7240                                                       return 1544;
7241                                                     }
7242                                                 }
7243                                             }
7244                                         }
7245                                     }
7246                                 }
7247                             }
7248                         }
7249                       else
7250                         {
7251                           if (((word >> 14) & 0x1) == 0)
7252                             {
7253                               if (((word >> 15) & 0x1) == 0)
7254                                 {
7255                                   if (((word >> 21) & 0x1) == 0)
7256                                     {
7257                                       if (((word >> 30) & 0x1) == 0)
7258                                         {
7259                                           if (((word >> 31) & 0x1) == 0)
7260                                             {
7261                                               if (((word >> 17) & 0x1) == 0)
7262                                                 {
7263                                                   if (((word >> 19) & 0x1) == 0)
7264                                                     {
7265                                                       if (((word >> 20) & 0x1) == 0)
7266                                                         {
7267                                                           if (((word >> 16) & 0x1) == 0)
7268                                                             {
7269                                                               /* 33222222222211111111110000000000
7270                                                                  10987654321098765432109876543210
7271                                                                  000001x0xx000x00001xxxxxxxxxxxxx
7272                                                                  saddv.  */
7273                                                               return 1823;
7274                                                             }
7275                                                           else
7276                                                             {
7277                                                               /* 33222222222211111111110000000000
7278                                                                  10987654321098765432109876543210
7279                                                                  000001x0xx000x01001xxxxxxxxxxxxx
7280                                                                  uaddv.  */
7281                                                               return 1975;
7282                                                             }
7283                                                         }
7284                                                       else
7285                                                         {
7286                                                           /* 33222222222211111111110000000000
7287                                                              10987654321098765432109876543210
7288                                                              000001x0xx010x0x001xxxxxxxxxxxxx
7289                                                              movprfx.  */
7290                                                           return 1758;
7291                                                         }
7292                                                     }
7293                                                   else
7294                                                     {
7295                                                       if (((word >> 16) & 0x1) == 0)
7296                                                         {
7297                                                           if (((word >> 20) & 0x1) == 0)
7298                                                             {
7299                                                               /* 33222222222211111111110000000000
7300                                                                  10987654321098765432109876543210
7301                                                                  000001x0xx001x00001xxxxxxxxxxxxx
7302                                                                  smaxv.  */
7303                                                               return 1841;
7304                                                             }
7305                                                           else
7306                                                             {
7307                                                               /* 33222222222211111111110000000000
7308                                                                  10987654321098765432109876543210
7309                                                                  000001x0xx011x00001xxxxxxxxxxxxx
7310                                                                  orv.  */
7311                                                               return 1775;
7312                                                             }
7313                                                         }
7314                                                       else
7315                                                         {
7316                                                           if (((word >> 20) & 0x1) == 0)
7317                                                             {
7318                                                               /* 33222222222211111111110000000000
7319                                                                  10987654321098765432109876543210
7320                                                                  000001x0xx001x01001xxxxxxxxxxxxx
7321                                                                  umaxv.  */
7322                                                               return 1990;
7323                                                             }
7324                                                           else
7325                                                             {
7326                                                               /* 33222222222211111111110000000000
7327                                                                  10987654321098765432109876543210
7328                                                                  000001x0xx011x01001xxxxxxxxxxxxx
7329                                                                  eorv.  */
7330                                                               return 1390;
7331                                                             }
7332                                                         }
7333                                                     }
7334                                                 }
7335                                               else
7336                                                 {
7337                                                   if (((word >> 16) & 0x1) == 0)
7338                                                     {
7339                                                       if (((word >> 20) & 0x1) == 0)
7340                                                         {
7341                                                           /* 33222222222211111111110000000000
7342                                                              10987654321098765432109876543210
7343                                                              000001x0xx00xx10001xxxxxxxxxxxxx
7344                                                              sminv.  */
7345                                                           return 1844;
7346                                                         }
7347                                                       else
7348                                                         {
7349                                                           /* 33222222222211111111110000000000
7350                                                              10987654321098765432109876543210
7351                                                              000001x0xx01xx10001xxxxxxxxxxxxx
7352                                                              andv.  */
7353                                                           return 1303;
7354                                                         }
7355                                                     }
7356                                                   else
7357                                                     {
7358                                                       /* 33222222222211111111110000000000
7359                                                          10987654321098765432109876543210
7360                                                          000001x0xx0xxx11001xxxxxxxxxxxxx
7361                                                          uminv.  */
7362                                                       return 1993;
7363                                                     }
7364                                                 }
7365                                             }
7366                                           else
7367                                             {
7368                                               if (((word >> 23) & 0x1) == 0)
7369                                                 {
7370                                                   /* 33222222222211111111110000000000
7371                                                      10987654321098765432109876543210
7372                                                      100001x00x0xxxxx001xxxxxxxxxxxxx
7373                                                      ldff1sb.  */
7374                                                   return 1674;
7375                                                 }
7376                                               else
7377                                                 {
7378                                                   /* 33222222222211111111110000000000
7379                                                      10987654321098765432109876543210
7380                                                      100001x01x0xxxxx001xxxxxxxxxxxxx
7381                                                      ldff1sh.  */
7382                                                   return 1685;
7383                                                 }
7384                                             }
7385                                         }
7386                                       else
7387                                         {
7388                                           if (((word >> 31) & 0x1) == 0)
7389                                             {
7390                                               if (((word >> 12) & 0x1) == 0)
7391                                                 {
7392                                                   /* 33222222222211111111110000000000
7393                                                      10987654321098765432109876543210
7394                                                      010001x0xx0xxxxx0010xxxxxxxxxxxx
7395                                                      cmla.  */
7396                                                   return 2075;
7397                                                 }
7398                                               else
7399                                                 {
7400                                                   /* 33222222222211111111110000000000
7401                                                      10987654321098765432109876543210
7402                                                      010001x0xx0xxxxx0011xxxxxxxxxxxx
7403                                                      sqrdcmlah.  */
7404                                                   return 2207;
7405                                                 }
7406                                             }
7407                                           else
7408                                             {
7409                                               if (((word >> 23) & 0x1) == 0)
7410                                                 {
7411                                                   /* 33222222222211111111110000000000
7412                                                      10987654321098765432109876543210
7413                                                      110001x00x0xxxxx001xxxxxxxxxxxxx
7414                                                      ldff1sb.  */
7415                                                   return 1681;
7416                                                 }
7417                                               else
7418                                                 {
7419                                                   /* 33222222222211111111110000000000
7420                                                      10987654321098765432109876543210
7421                                                      110001x01x0xxxxx001xxxxxxxxxxxxx
7422                                                      ldff1sh.  */
7423                                                   return 1691;
7424                                                 }
7425                                             }
7426                                         }
7427                                     }
7428                                   else
7429                                     {
7430                                       if (((word >> 30) & 0x1) == 0)
7431                                         {
7432                                           if (((word >> 31) & 0x1) == 0)
7433                                             {
7434                                               if (((word >> 10) & 0x1) == 0)
7435                                                 {
7436                                                   if (((word >> 11) & 0x1) == 0)
7437                                                     {
7438                                                       if (((word >> 22) & 0x1) == 0)
7439                                                         {
7440                                                           if (((word >> 23) & 0x1) == 0)
7441                                                             {
7442                                                               /* 33222222222211111111110000000000
7443                                                                  10987654321098765432109876543210
7444                                                                  000001x0001xxxxx001x00xxxxxxxxxx
7445                                                                  and.  */
7446                                                               return 1298;
7447                                                             }
7448                                                           else
7449                                                             {
7450                                                               /* 33222222222211111111110000000000
7451                                                                  10987654321098765432109876543210
7452                                                                  000001x0101xxxxx001x00xxxxxxxxxx
7453                                                                  eor.  */
7454                                                               return 1385;
7455                                                             }
7456                                                         }
7457                                                       else
7458                                                         {
7459                                                           if (((word >> 23) & 0x1) == 0)
7460                                                             {
7461                                                               /* 33222222222211111111110000000000
7462                                                                  10987654321098765432109876543210
7463                                                                  000001x0011xxxxx001x00xxxxxxxxxx
7464                                                                  orr.  */
7465                                                               return 1770;
7466                                                             }
7467                                                           else
7468                                                             {
7469                                                               /* 33222222222211111111110000000000
7470                                                                  10987654321098765432109876543210
7471                                                                  000001x0111xxxxx001x00xxxxxxxxxx
7472                                                                  bic.  */
7473                                                               return 1311;
7474                                                             }
7475                                                         }
7476                                                     }
7477                                                   else
7478                                                     {
7479                                                       if (((word >> 22) & 0x1) == 0)
7480                                                         {
7481                                                           /* 33222222222211111111110000000000
7482                                                              10987654321098765432109876543210
7483                                                              000001x0x01xxxxx001x10xxxxxxxxxx
7484                                                              eor3.  */
7485                                                           return 2078;
7486                                                         }
7487                                                       else
7488                                                         {
7489                                                           /* 33222222222211111111110000000000
7490                                                              10987654321098765432109876543210
7491                                                              000001x0x11xxxxx001x10xxxxxxxxxx
7492                                                              bcax.  */
7493                                                           return 2067;
7494                                                         }
7495                                                     }
7496                                                 }
7497                                               else
7498                                                 {
7499                                                   if (((word >> 11) & 0x1) == 0)
7500                                                     {
7501                                                       /* 33222222222211111111110000000000
7502                                                          10987654321098765432109876543210
7503                                                          000001x0xx1xxxxx001x01xxxxxxxxxx
7504                                                          xar.  */
7505                                                       return 2340;
7506                                                     }
7507                                                   else
7508                                                     {
7509                                                       if (((word >> 22) & 0x1) == 0)
7510                                                         {
7511                                                           if (((word >> 23) & 0x1) == 0)
7512                                                             {
7513                                                               /* 33222222222211111111110000000000
7514                                                                  10987654321098765432109876543210
7515                                                                  000001x0001xxxxx001x11xxxxxxxxxx
7516                                                                  bsl.  */
7517                                                               return 2068;
7518                                                             }
7519                                                           else
7520                                                             {
7521                                                               /* 33222222222211111111110000000000
7522                                                                  10987654321098765432109876543210
7523                                                                  000001x0101xxxxx001x11xxxxxxxxxx
7524                                                                  bsl2n.  */
7525                                                               return 2070;
7526                                                             }
7527                                                         }
7528                                                       else
7529                                                         {
7530                                                           if (((word >> 23) & 0x1) == 0)
7531                                                             {
7532                                                               /* 33222222222211111111110000000000
7533                                                                  10987654321098765432109876543210
7534                                                                  000001x0011xxxxx001x11xxxxxxxxxx
7535                                                                  bsl1n.  */
7536                                                               return 2069;
7537                                                             }
7538                                                           else
7539                                                             {
7540                                                               /* 33222222222211111111110000000000
7541                                                                  10987654321098765432109876543210
7542                                                                  000001x0111xxxxx001x11xxxxxxxxxx
7543                                                                  nbsl.  */
7544                                                               return 2125;
7545                                                             }
7546                                                         }
7547                                                     }
7548                                                 }
7549                                             }
7550                                           else
7551                                             {
7552                                               if (((word >> 23) & 0x1) == 0)
7553                                                 {
7554                                                   /* 33222222222211111111110000000000
7555                                                      10987654321098765432109876543210
7556                                                      100001x00x1xxxxx001xxxxxxxxxxxxx
7557                                                      prfh.  */
7558                                                   return 1793;
7559                                                 }
7560                                               else
7561                                                 {
7562                                                   /* 33222222222211111111110000000000
7563                                                      10987654321098765432109876543210
7564                                                      100001x01x1xxxxx001xxxxxxxxxxxxx
7565                                                      ldff1sh.  */
7566                                                   return 1686;
7567                                                 }
7568                                             }
7569                                         }
7570                                       else
7571                                         {
7572                                           if (((word >> 23) & 0x1) == 0)
7573                                             {
7574                                               /* 33222222222211111111110000000000
7575                                                  10987654321098765432109876543210
7576                                                  x10001x00x1xxxxx001xxxxxxxxxxxxx
7577                                                  prfh.  */
7578                                               return 1795;
7579                                             }
7580                                           else
7581                                             {
7582                                               if (((word >> 31) & 0x1) == 0)
7583                                                 {
7584                                                   if (((word >> 10) & 0x1) == 0)
7585                                                     {
7586                                                       if (((word >> 12) & 0x1) == 0)
7587                                                         {
7588                                                           if (((word >> 22) & 0x1) == 0)
7589                                                             {
7590                                                               /* 33222222222211111111110000000000
7591                                                                  10987654321098765432109876543210
7592                                                                  010001x0101xxxxx0010x0xxxxxxxxxx
7593                                                                  sqdmlalb.  */
7594                                                               return 2180;
7595                                                             }
7596                                                           else
7597                                                             {
7598                                                               /* 33222222222211111111110000000000
7599                                                                  10987654321098765432109876543210
7600                                                                  010001x0111xxxxx0010x0xxxxxxxxxx
7601                                                                  sqdmlalb.  */
7602                                                               return 2181;
7603                                                             }
7604                                                         }
7605                                                       else
7606                                                         {
7607                                                           if (((word >> 22) & 0x1) == 0)
7608                                                             {
7609                                                               /* 33222222222211111111110000000000
7610                                                                  10987654321098765432109876543210
7611                                                                  010001x0101xxxxx0011x0xxxxxxxxxx
7612                                                                  sqdmlslb.  */
7613                                                               return 2187;
7614                                                             }
7615                                                           else
7616                                                             {
7617                                                               /* 33222222222211111111110000000000
7618                                                                  10987654321098765432109876543210
7619                                                                  010001x0111xxxxx0011x0xxxxxxxxxx
7620                                                                  sqdmlslb.  */
7621                                                               return 2188;
7622                                                             }
7623                                                         }
7624                                                     }
7625                                                   else
7626                                                     {
7627                                                       if (((word >> 12) & 0x1) == 0)
7628                                                         {
7629                                                           if (((word >> 22) & 0x1) == 0)
7630                                                             {
7631                                                               /* 33222222222211111111110000000000
7632                                                                  10987654321098765432109876543210
7633                                                                  010001x0101xxxxx0010x1xxxxxxxxxx
7634                                                                  sqdmlalt.  */
7635                                                               return 2184;
7636                                                             }
7637                                                           else
7638                                                             {
7639                                                               /* 33222222222211111111110000000000
7640                                                                  10987654321098765432109876543210
7641                                                                  010001x0111xxxxx0010x1xxxxxxxxxx
7642                                                                  sqdmlalt.  */
7643                                                               return 2185;
7644                                                             }
7645                                                         }
7646                                                       else
7647                                                         {
7648                                                           if (((word >> 22) & 0x1) == 0)
7649                                                             {
7650                                                               /* 33222222222211111111110000000000
7651                                                                  10987654321098765432109876543210
7652                                                                  010001x0101xxxxx0011x1xxxxxxxxxx
7653                                                                  sqdmlslt.  */
7654                                                               return 2191;
7655                                                             }
7656                                                           else
7657                                                             {
7658                                                               /* 33222222222211111111110000000000
7659                                                                  10987654321098765432109876543210
7660                                                                  010001x0111xxxxx0011x1xxxxxxxxxx
7661                                                                  sqdmlslt.  */
7662                                                               return 2192;
7663                                                             }
7664                                                         }
7665                                                     }
7666                                                 }
7667                                               else
7668                                                 {
7669                                                   /* 33222222222211111111110000000000
7670                                                      10987654321098765432109876543210
7671                                                      110001x01x1xxxxx001xxxxxxxxxxxxx
7672                                                      ldff1sh.  */
7673                                                   return 1692;
7674                                                 }
7675                                             }
7676                                         }
7677                                     }
7678                                 }
7679                               else
7680                                 {
7681                                   if (((word >> 30) & 0x1) == 0)
7682                                     {
7683                                       if (((word >> 31) & 0x1) == 0)
7684                                         {
7685                                           if (((word >> 21) & 0x1) == 0)
7686                                             {
7687                                               if (((word >> 16) & 0x1) == 0)
7688                                                 {
7689                                                   if (((word >> 17) & 0x1) == 0)
7690                                                     {
7691                                                       if (((word >> 18) & 0x1) == 0)
7692                                                         {
7693                                                           if (((word >> 19) & 0x1) == 0)
7694                                                             {
7695                                                               /* 33222222222211111111110000000000
7696                                                                  10987654321098765432109876543210
7697                                                                  000001x0xx0x0000101xxxxxxxxxxxxx
7698                                                                  sxtb.  */
7699                                                               return 1966;
7700                                                             }
7701                                                           else
7702                                                             {
7703                                                               /* 33222222222211111111110000000000
7704                                                                  10987654321098765432109876543210
7705                                                                  000001x0xx0x1000101xxxxxxxxxxxxx
7706                                                                  cls.  */
7707                                                               return 1331;
7708                                                             }
7709                                                         }
7710                                                       else
7711                                                         {
7712                                                           if (((word >> 19) & 0x1) == 0)
7713                                                             {
7714                                                               /* 33222222222211111111110000000000
7715                                                                  10987654321098765432109876543210
7716                                                                  000001x0xx0x0100101xxxxxxxxxxxxx
7717                                                                  sxtw.  */
7718                                                               return 1968;
7719                                                             }
7720                                                           else
7721                                                             {
7722                                                               /* 33222222222211111111110000000000
7723                                                                  10987654321098765432109876543210
7724                                                                  000001x0xx0x1100101xxxxxxxxxxxxx
7725                                                                  fabs.  */
7726                                                               return 1393;
7727                                                             }
7728                                                         }
7729                                                     }
7730                                                   else
7731                                                     {
7732                                                       if (((word >> 18) & 0x1) == 0)
7733                                                         {
7734                                                           if (((word >> 19) & 0x1) == 0)
7735                                                             {
7736                                                               /* 33222222222211111111110000000000
7737                                                                  10987654321098765432109876543210
7738                                                                  000001x0xx0x0010101xxxxxxxxxxxxx
7739                                                                  sxth.  */
7740                                                               return 1967;
7741                                                             }
7742                                                           else
7743                                                             {
7744                                                               /* 33222222222211111111110000000000
7745                                                                  10987654321098765432109876543210
7746                                                                  000001x0xx0x1010101xxxxxxxxxxxxx
7747                                                                  cnt.  */
7748                                                               return 1360;
7749                                                             }
7750                                                         }
7751                                                       else
7752                                                         {
7753                                                           if (((word >> 19) & 0x1) == 0)
7754                                                             {
7755                                                               /* 33222222222211111111110000000000
7756                                                                  10987654321098765432109876543210
7757                                                                  000001x0xx0x0110101xxxxxxxxxxxxx
7758                                                                  abs.  */
7759                                                               return 1289;
7760                                                             }
7761                                                           else
7762                                                             {
7763                                                               /* 33222222222211111111110000000000
7764                                                                  10987654321098765432109876543210
7765                                                                  000001x0xx0x1110101xxxxxxxxxxxxx
7766                                                                  not.  */
7767                                                               return 1767;
7768                                                             }
7769                                                         }
7770                                                     }
7771                                                 }
7772                                               else
7773                                                 {
7774                                                   if (((word >> 17) & 0x1) == 0)
7775                                                     {
7776                                                       if (((word >> 18) & 0x1) == 0)
7777                                                         {
7778                                                           if (((word >> 19) & 0x1) == 0)
7779                                                             {
7780                                                               /* 33222222222211111111110000000000
7781                                                                  10987654321098765432109876543210
7782                                                                  000001x0xx0x0001101xxxxxxxxxxxxx
7783                                                                  uxtb.  */
7784                                                               return 2029;
7785                                                             }
7786                                                           else
7787                                                             {
7788                                                               /* 33222222222211111111110000000000
7789                                                                  10987654321098765432109876543210
7790                                                                  000001x0xx0x1001101xxxxxxxxxxxxx
7791                                                                  clz.  */
7792                                                               return 1332;
7793                                                             }
7794                                                         }
7795                                                       else
7796                                                         {
7797                                                           if (((word >> 19) & 0x1) == 0)
7798                                                             {
7799                                                               /* 33222222222211111111110000000000
7800                                                                  10987654321098765432109876543210
7801                                                                  000001x0xx0x0101101xxxxxxxxxxxxx
7802                                                                  uxtw.  */
7803                                                               return 2031;
7804                                                             }
7805                                                           else
7806                                                             {
7807                                                               /* 33222222222211111111110000000000
7808                                                                  10987654321098765432109876543210
7809                                                                  000001x0xx0x1101101xxxxxxxxxxxxx
7810                                                                  fneg.  */
7811                                                               return 1470;
7812                                                             }
7813                                                         }
7814                                                     }
7815                                                   else
7816                                                     {
7817                                                       if (((word >> 18) & 0x1) == 0)
7818                                                         {
7819                                                           if (((word >> 19) & 0x1) == 0)
7820                                                             {
7821                                                               /* 33222222222211111111110000000000
7822                                                                  10987654321098765432109876543210
7823                                                                  000001x0xx0x0011101xxxxxxxxxxxxx
7824                                                                  uxth.  */
7825                                                               return 2030;
7826                                                             }
7827                                                           else
7828                                                             {
7829                                                               /* 33222222222211111111110000000000
7830                                                                  10987654321098765432109876543210
7831                                                                  000001x0xx0x1011101xxxxxxxxxxxxx
7832                                                                  cnot.  */
7833                                                               return 1359;
7834                                                             }
7835                                                         }
7836                                                       else
7837                                                         {
7838                                                           /* 33222222222211111111110000000000
7839                                                              10987654321098765432109876543210
7840                                                              000001x0xx0xx111101xxxxxxxxxxxxx
7841                                                              neg.  */
7842                                                           return 1764;
7843                                                         }
7844                                                     }
7845                                                 }
7846                                             }
7847                                           else
7848                                             {
7849                                               if (((word >> 12) & 0x1) == 0)
7850                                                 {
7851                                                   if (((word >> 23) & 0x1) == 0)
7852                                                     {
7853                                                       if (((word >> 22) & 0x1) == 0)
7854                                                         {
7855                                                           /* 33222222222211111111110000000000
7856                                                              10987654321098765432109876543210
7857                                                              000001x0001xxxxx1010xxxxxxxxxxxx
7858                                                              adr.  */
7859                                                           return 1295;
7860                                                         }
7861                                                       else
7862                                                         {
7863                                                           /* 33222222222211111111110000000000
7864                                                              10987654321098765432109876543210
7865                                                              000001x0011xxxxx1010xxxxxxxxxxxx
7866                                                              adr.  */
7867                                                           return 1296;
7868                                                         }
7869                                                     }
7870                                                   else
7871                                                     {
7872                                                       /* 33222222222211111111110000000000
7873                                                          10987654321098765432109876543210
7874                                                          000001x01x1xxxxx1010xxxxxxxxxxxx
7875                                                          adr.  */
7876                                                       return 1297;
7877                                                     }
7878                                                 }
7879                                               else
7880                                                 {
7881                                                   if (((word >> 10) & 0x1) == 0)
7882                                                     {
7883                                                       if (((word >> 11) & 0x1) == 0)
7884                                                         {
7885                                                           /* 33222222222211111111110000000000
7886                                                              10987654321098765432109876543210
7887                                                              000001x0xx1xxxxx101100xxxxxxxxxx
7888                                                              ftssel.  */
7889                                                           return 1496;
7890                                                         }
7891                                                       else
7892                                                         {
7893                                                           /* 33222222222211111111110000000000
7894                                                              10987654321098765432109876543210
7895                                                              000001x0xx1xxxxx101110xxxxxxxxxx
7896                                                              fexpa.  */
7897                                                           return 1440;
7898                                                         }
7899                                                     }
7900                                                   else
7901                                                     {
7902                                                       /* 33222222222211111111110000000000
7903                                                          10987654321098765432109876543210
7904                                                          000001x0xx1xxxxx1011x1xxxxxxxxxx
7905                                                          movprfx.  */
7906                                                       return 1757;
7907                                                     }
7908                                                 }
7909                                             }
7910                                         }
7911                                       else
7912                                         {
7913                                           if (((word >> 22) & 0x1) == 0)
7914                                             {
7915                                               if (((word >> 21) & 0x1) == 0)
7916                                                 {
7917                                                   if (((word >> 23) & 0x1) == 0)
7918                                                     {
7919                                                       /* 33222222222211111111110000000000
7920                                                          10987654321098765432109876543210
7921                                                          100001x0000xxxxx101xxxxxxxxxxxxx
7922                                                          ldnt1b.  */
7923                                                       return 2104;
7924                                                     }
7925                                                   else
7926                                                     {
7927                                                       /* 33222222222211111111110000000000
7928                                                          10987654321098765432109876543210
7929                                                          100001x0100xxxxx101xxxxxxxxxxxxx
7930                                                          ldnt1h.  */
7931                                                       return 2107;
7932                                                     }
7933                                                 }
7934                                               else
7935                                                 {
7936                                                   if (((word >> 23) & 0x1) == 0)
7937                                                     {
7938                                                       /* 33222222222211111111110000000000
7939                                                          10987654321098765432109876543210
7940                                                          100001x0001xxxxx101xxxxxxxxxxxxx
7941                                                          ldff1sb.  */
7942                                                       return 1683;
7943                                                     }
7944                                                   else
7945                                                     {
7946                                                       /* 33222222222211111111110000000000
7947                                                          10987654321098765432109876543210
7948                                                          100001x0101xxxxx101xxxxxxxxxxxxx
7949                                                          ldff1sh.  */
7950                                                       return 1695;
7951                                                     }
7952                                                 }
7953                                             }
7954                                           else
7955                                             {
7956                                               if (((word >> 23) & 0x1) == 0)
7957                                                 {
7958                                                   /* 33222222222211111111110000000000
7959                                                      10987654321098765432109876543210
7960                                                      100001x001xxxxxx101xxxxxxxxxxxxx
7961                                                      ld1rb.  */
7962                                                   return 1551;
7963                                                 }
7964                                               else
7965                                                 {
7966                                                   /* 33222222222211111111110000000000
7967                                                      10987654321098765432109876543210
7968                                                      100001x011xxxxxx101xxxxxxxxxxxxx
7969                                                      ld1rh.  */
7970                                                   return 1555;
7971                                                 }
7972                                             }
7973                                         }
7974                                     }
7975                                   else
7976                                     {
7977                                       if (((word >> 21) & 0x1) == 0)
7978                                         {
7979                                           if (((word >> 31) & 0x1) == 0)
7980                                             {
7981                                               if (((word >> 16) & 0x1) == 0)
7982                                                 {
7983                                                   if (((word >> 17) & 0x1) == 0)
7984                                                     {
7985                                                       if (((word >> 18) & 0x1) == 0)
7986                                                         {
7987                                                           if (((word >> 19) & 0x1) == 0)
7988                                                             {
7989                                                               /* 33222222222211111111110000000000
7990                                                                  10987654321098765432109876543210
7991                                                                  010001x0xx0x0000101xxxxxxxxxxxxx
7992                                                                  urecpe.  */
7993                                                               return 2315;
7994                                                             }
7995                                                           else
7996                                                             {
7997                                                               /* 33222222222211111111110000000000
7998                                                                  10987654321098765432109876543210
7999                                                                  010001x0xx0x1000101xxxxxxxxxxxxx
8000                                                                  sqabs.  */
8001                                                               return 2177;
8002                                                             }
8003                                                         }
8004                                                       else
8005                                                         {
8006                                                           if (((word >> 20) & 0x1) == 0)
8007                                                             {
8008                                                               /* 33222222222211111111110000000000
8009                                                                  10987654321098765432109876543210
8010                                                                  010001x0xx00x100101xxxxxxxxxxxxx
8011                                                                  sadalp.  */
8012                                                               return 2141;
8013                                                             }
8014                                                           else
8015                                                             {
8016                                                               /* 33222222222211111111110000000000
8017                                                                  10987654321098765432109876543210
8018                                                                  010001x0xx01x100101xxxxxxxxxxxxx
8019                                                                  smaxp.  */
8020                                                               return 2155;
8021                                                             }
8022                                                         }
8023                                                     }
8024                                                   else
8025                                                     {
8026                                                       /* 33222222222211111111110000000000
8027                                                          10987654321098765432109876543210
8028                                                          010001x0xx0xxx10101xxxxxxxxxxxxx
8029                                                          sminp.  */
8030                                                       return 2156;
8031                                                     }
8032                                                 }
8033                                               else
8034                                                 {
8035                                                   if (((word >> 17) & 0x1) == 0)
8036                                                     {
8037                                                       if (((word >> 18) & 0x1) == 0)
8038                                                         {
8039                                                           if (((word >> 19) & 0x1) == 0)
8040                                                             {
8041                                                               if (((word >> 20) & 0x1) == 0)
8042                                                                 {
8043                                                                   /* 33222222222211111111110000000000
8044                                                                      10987654321098765432109876543210
8045                                                                      010001x0xx000001101xxxxxxxxxxxxx
8046                                                                      ursqrte.  */
8047                                                                   return 2320;
8048                                                                 }
8049                                                               else
8050                                                                 {
8051                                                                   /* 33222222222211111111110000000000
8052                                                                      10987654321098765432109876543210
8053                                                                      010001x0xx010001101xxxxxxxxxxxxx
8054                                                                      addp.  */
8055                                                                   return 2066;
8056                                                                 }
8057                                                             }
8058                                                           else
8059                                                             {
8060                                                               /* 33222222222211111111110000000000
8061                                                                  10987654321098765432109876543210
8062                                                                  010001x0xx0x1001101xxxxxxxxxxxxx
8063                                                                  sqneg.  */
8064                                                               return 2204;
8065                                                             }
8066                                                         }
8067                                                       else
8068                                                         {
8069                                                           if (((word >> 20) & 0x1) == 0)
8070                                                             {
8071                                                               /* 33222222222211111111110000000000
8072                                                                  10987654321098765432109876543210
8073                                                                  010001x0xx00x101101xxxxxxxxxxxxx
8074                                                                  uadalp.  */
8075                                                               return 2272;
8076                                                             }
8077                                                           else
8078                                                             {
8079                                                               /* 33222222222211111111110000000000
8080                                                                  10987654321098765432109876543210
8081                                                                  010001x0xx01x101101xxxxxxxxxxxxx
8082                                                                  umaxp.  */
8083                                                               return 2280;
8084                                                             }
8085                                                         }
8086                                                     }
8087                                                   else
8088                                                     {
8089                                                       /* 33222222222211111111110000000000
8090                                                          10987654321098765432109876543210
8091                                                          010001x0xx0xxx11101xxxxxxxxxxxxx
8092                                                          uminp.  */
8093                                                       return 2281;
8094                                                     }
8095                                                 }
8096                                             }
8097                                           else
8098                                             {
8099                                               if (((word >> 23) & 0x1) == 0)
8100                                                 {
8101                                                   /* 33222222222211111111110000000000
8102                                                      10987654321098765432109876543210
8103                                                      110001x00x0xxxxx101xxxxxxxxxxxxx
8104                                                      ldff1sb.  */
8105                                                   return 1682;
8106                                                 }
8107                                               else
8108                                                 {
8109                                                   /* 33222222222211111111110000000000
8110                                                      10987654321098765432109876543210
8111                                                      110001x01x0xxxxx101xxxxxxxxxxxxx
8112                                                      ldff1sh.  */
8113                                                   return 1693;
8114                                                 }
8115                                             }
8116                                         }
8117                                       else
8118                                         {
8119                                           if (((word >> 22) & 0x1) == 0)
8120                                             {
8121                                               if (((word >> 23) & 0x1) == 0)
8122                                                 {
8123                                                   /* 33222222222211111111110000000000
8124                                                      10987654321098765432109876543210
8125                                                      x10001x0001xxxxx101xxxxxxxxxxxxx
8126                                                      ldff1sb.  */
8127                                                   return 1684;
8128                                                 }
8129                                               else
8130                                                 {
8131                                                   if (((word >> 31) & 0x1) == 0)
8132                                                     {
8133                                                       if (((word >> 10) & 0x1) == 0)
8134                                                         {
8135                                                           if (((word >> 12) & 0x1) == 0)
8136                                                             {
8137                                                               /* 33222222222211111111110000000000
8138                                                                  10987654321098765432109876543210
8139                                                                  010001x0101xxxxx1010x0xxxxxxxxxx
8140                                                                  smlslb.  */
8141                                                               return 2163;
8142                                                             }
8143                                                           else
8144                                                             {
8145                                                               /* 33222222222211111111110000000000
8146                                                                  10987654321098765432109876543210
8147                                                                  010001x0101xxxxx1011x0xxxxxxxxxx
8148                                                                  umlslb.  */
8149                                                               return 2288;
8150                                                             }
8151                                                         }
8152                                                       else
8153                                                         {
8154                                                           if (((word >> 12) & 0x1) == 0)
8155                                                             {
8156                                                               /* 33222222222211111111110000000000
8157                                                                  10987654321098765432109876543210
8158                                                                  010001x0101xxxxx1010x1xxxxxxxxxx
8159                                                                  smlslt.  */
8160                                                               return 2166;
8161                                                             }
8162                                                           else
8163                                                             {
8164                                                               /* 33222222222211111111110000000000
8165                                                                  10987654321098765432109876543210
8166                                                                  010001x0101xxxxx1011x1xxxxxxxxxx
8167                                                                  umlslt.  */
8168                                                               return 2291;
8169                                                             }
8170                                                         }
8171                                                     }
8172                                                   else
8173                                                     {
8174                                                       /* 33222222222211111111110000000000
8175                                                          10987654321098765432109876543210
8176                                                          110001x0101xxxxx101xxxxxxxxxxxxx
8177                                                          ldff1sh.  */
8178                                                       return 1696;
8179                                                     }
8180                                                 }
8181                                             }
8182                                           else
8183                                             {
8184                                               if (((word >> 23) & 0x1) == 0)
8185                                                 {
8186                                                   /* 33222222222211111111110000000000
8187                                                      10987654321098765432109876543210
8188                                                      x10001x0011xxxxx101xxxxxxxxxxxxx
8189                                                      prfh.  */
8190                                                   return 1796;
8191                                                 }
8192                                               else
8193                                                 {
8194                                                   if (((word >> 31) & 0x1) == 0)
8195                                                     {
8196                                                       if (((word >> 10) & 0x1) == 0)
8197                                                         {
8198                                                           if (((word >> 12) & 0x1) == 0)
8199                                                             {
8200                                                               /* 33222222222211111111110000000000
8201                                                                  10987654321098765432109876543210
8202                                                                  010001x0111xxxxx1010x0xxxxxxxxxx
8203                                                                  smlslb.  */
8204                                                               return 2164;
8205                                                             }
8206                                                           else
8207                                                             {
8208                                                               /* 33222222222211111111110000000000
8209                                                                  10987654321098765432109876543210
8210                                                                  010001x0111xxxxx1011x0xxxxxxxxxx
8211                                                                  umlslb.  */
8212                                                               return 2289;
8213                                                             }
8214                                                         }
8215                                                       else
8216                                                         {
8217                                                           if (((word >> 12) & 0x1) == 0)
8218                                                             {
8219                                                               /* 33222222222211111111110000000000
8220                                                                  10987654321098765432109876543210
8221                                                                  010001x0111xxxxx1010x1xxxxxxxxxx
8222                                                                  smlslt.  */
8223                                                               return 2167;
8224                                                             }
8225                                                           else
8226                                                             {
8227                                                               /* 33222222222211111111110000000000
8228                                                                  10987654321098765432109876543210
8229                                                                  010001x0111xxxxx1011x1xxxxxxxxxx
8230                                                                  umlslt.  */
8231                                                               return 2292;
8232                                                             }
8233                                                         }
8234                                                     }
8235                                                   else
8236                                                     {
8237                                                       /* 33222222222211111111110000000000
8238                                                          10987654321098765432109876543210
8239                                                          110001x0111xxxxx101xxxxxxxxxxxxx
8240                                                          ldff1sh.  */
8241                                                       return 1694;
8242                                                     }
8243                                                 }
8244                                             }
8245                                         }
8246                                     }
8247                                 }
8248                             }
8249                           else
8250                             {
8251                               if (((word >> 15) & 0x1) == 0)
8252                                 {
8253                                   if (((word >> 21) & 0x1) == 0)
8254                                     {
8255                                       if (((word >> 30) & 0x1) == 0)
8256                                         {
8257                                           if (((word >> 31) & 0x1) == 0)
8258                                             {
8259                                               /* 33222222222211111111110000000000
8260                                                  10987654321098765432109876543210
8261                                                  000001x0xx0xxxxx011xxxxxxxxxxxxx
8262                                                  mls.  */
8263                                               return 1756;
8264                                             }
8265                                           else
8266                                             {
8267                                               if (((word >> 23) & 0x1) == 0)
8268                                                 {
8269                                                   /* 33222222222211111111110000000000
8270                                                      10987654321098765432109876543210
8271                                                      100001x00x0xxxxx011xxxxxxxxxxxxx
8272                                                      ldff1b.  */
8273                                                   return 1640;
8274                                                 }
8275                                               else
8276                                                 {
8277                                                   /* 33222222222211111111110000000000
8278                                                      10987654321098765432109876543210
8279                                                      100001x01x0xxxxx011xxxxxxxxxxxxx
8280                                                      ldff1h.  */
8281                                                   return 1660;
8282                                                 }
8283                                             }
8284                                         }
8285                                       else
8286                                         {
8287                                           if (((word >> 31) & 0x1) == 0)
8288                                             {
8289                                               if (((word >> 10) & 0x1) == 0)
8290                                                 {
8291                                                   if (((word >> 11) & 0x1) == 0)
8292                                                     {
8293                                                       if (((word >> 12) & 0x1) == 0)
8294                                                         {
8295                                                           /* 33222222222211111111110000000000
8296                                                              10987654321098765432109876543210
8297                                                              010001x0xx0xxxxx011000xxxxxxxxxx
8298                                                              sqdmlalb.  */
8299                                                           return 2182;
8300                                                         }
8301                                                       else
8302                                                         {
8303                                                           /* 33222222222211111111110000000000
8304                                                              10987654321098765432109876543210
8305                                                              010001x0xx0xxxxx011100xxxxxxxxxx
8306                                                              sqrdmlah.  */
8307                                                           return 2211;
8308                                                         }
8309                                                     }
8310                                                   else
8311                                                     {
8312                                                       if (((word >> 12) & 0x1) == 0)
8313                                                         {
8314                                                           /* 33222222222211111111110000000000
8315                                                              10987654321098765432109876543210
8316                                                              010001x0xx0xxxxx011010xxxxxxxxxx
8317                                                              sqdmlslb.  */
8318                                                           return 2189;
8319                                                         }
8320                                                       else
8321                                                         {
8322                                                           /* 33222222222211111111110000000000
8323                                                              10987654321098765432109876543210
8324                                                              010001x0xx0xxxxx011110xxxxxxxxxx
8325                                                              usdot.  */
8326                                                           return 2471;
8327                                                         }
8328                                                     }
8329                                                 }
8330                                               else
8331                                                 {
8332                                                   if (((word >> 11) & 0x1) == 0)
8333                                                     {
8334                                                       if (((word >> 12) & 0x1) == 0)
8335                                                         {
8336                                                           /* 33222222222211111111110000000000
8337                                                              10987654321098765432109876543210
8338                                                              010001x0xx0xxxxx011001xxxxxxxxxx
8339                                                              sqdmlalt.  */
8340                                                           return 2186;
8341                                                         }
8342                                                       else
8343                                                         {
8344                                                           /* 33222222222211111111110000000000
8345                                                              10987654321098765432109876543210
8346                                                              010001x0xx0xxxxx011101xxxxxxxxxx
8347                                                              sqrdmlsh.  */
8348                                                           return 2215;
8349                                                         }
8350                                                     }
8351                                                   else
8352                                                     {
8353                                                       /* 33222222222211111111110000000000
8354                                                          10987654321098765432109876543210
8355                                                          010001x0xx0xxxxx011x11xxxxxxxxxx
8356                                                          sqdmlslt.  */
8357                                                       return 2193;
8358                                                     }
8359                                                 }
8360                                             }
8361                                           else
8362                                             {
8363                                               if (((word >> 23) & 0x1) == 0)
8364                                                 {
8365                                                   /* 33222222222211111111110000000000
8366                                                      10987654321098765432109876543210
8367                                                      110001x00x0xxxxx011xxxxxxxxxxxxx
8368                                                      ldff1b.  */
8369                                                   return 1649;
8370                                                 }
8371                                               else
8372                                                 {
8373                                                   /* 33222222222211111111110000000000
8374                                                      10987654321098765432109876543210
8375                                                      110001x01x0xxxxx011xxxxxxxxxxxxx
8376                                                      ldff1h.  */
8377                                                   return 1668;
8378                                                 }
8379                                             }
8380                                         }
8381                                     }
8382                                   else
8383                                     {
8384                                       if (((word >> 30) & 0x1) == 0)
8385                                         {
8386                                           if (((word >> 31) & 0x1) == 0)
8387                                             {
8388                                               if (((word >> 10) & 0x1) == 0)
8389                                                 {
8390                                                   if (((word >> 11) & 0x1) == 0)
8391                                                     {
8392                                                       if (((word >> 12) & 0x1) == 0)
8393                                                         {
8394                                                           /* 33222222222211111111110000000000
8395                                                              10987654321098765432109876543210
8396                                                              000001x0xx1xxxxx011000xxxxxxxxxx
8397                                                              mul.  */
8398                                                           return 2124;
8399                                                         }
8400                                                       else
8401                                                         {
8402                                                           /* 33222222222211111111110000000000
8403                                                              10987654321098765432109876543210
8404                                                              000001x0xx1xxxxx011100xxxxxxxxxx
8405                                                              sqdmulh.  */
8406                                                           return 2197;
8407                                                         }
8408                                                     }
8409                                                   else
8410                                                     {
8411                                                       /* 33222222222211111111110000000000
8412                                                          10987654321098765432109876543210
8413                                                          000001x0xx1xxxxx011x10xxxxxxxxxx
8414                                                          smulh.  */
8415                                                       return 2169;
8416                                                     }
8417                                                 }
8418                                               else
8419                                                 {
8420                                                   if (((word >> 11) & 0x1) == 0)
8421                                                     {
8422                                                       if (((word >> 12) & 0x1) == 0)
8423                                                         {
8424                                                           /* 33222222222211111111110000000000
8425                                                              10987654321098765432109876543210
8426                                                              000001x0xx1xxxxx011001xxxxxxxxxx
8427                                                              pmul.  */
8428                                                           return 2127;
8429                                                         }
8430                                                       else
8431                                                         {
8432                                                           /* 33222222222211111111110000000000
8433                                                              10987654321098765432109876543210
8434                                                              000001x0xx1xxxxx011101xxxxxxxxxx
8435                                                              sqrdmulh.  */
8436                                                           return 2219;
8437                                                         }
8438                                                     }
8439                                                   else
8440                                                     {
8441                                                       /* 33222222222211111111110000000000
8442                                                          10987654321098765432109876543210
8443                                                          000001x0xx1xxxxx011x11xxxxxxxxxx
8444                                                          umulh.  */
8445                                                       return 2294;
8446                                                     }
8447                                                 }
8448                                             }
8449                                           else
8450                                             {
8451                                               if (((word >> 23) & 0x1) == 0)
8452                                                 {
8453                                                   /* 33222222222211111111110000000000
8454                                                      10987654321098765432109876543210
8455                                                      100001x00x1xxxxx011xxxxxxxxxxxxx
8456                                                      prfd.  */
8457                                                   return 1786;
8458                                                 }
8459                                               else
8460                                                 {
8461                                                   /* 33222222222211111111110000000000
8462                                                      10987654321098765432109876543210
8463                                                      100001x01x1xxxxx011xxxxxxxxxxxxx
8464                                                      ldff1h.  */
8465                                                   return 1661;
8466                                                 }
8467                                             }
8468                                         }
8469                                       else
8470                                         {
8471                                           if (((word >> 23) & 0x1) == 0)
8472                                             {
8473                                               /* 33222222222211111111110000000000
8474                                                  10987654321098765432109876543210
8475                                                  x10001x00x1xxxxx011xxxxxxxxxxxxx
8476                                                  prfd.  */
8477                                               return 1788;
8478                                             }
8479                                           else
8480                                             {
8481                                               if (((word >> 31) & 0x1) == 0)
8482                                                 {
8483                                                   if (((word >> 12) & 0x1) == 0)
8484                                                     {
8485                                                       if (((word >> 22) & 0x1) == 0)
8486                                                         {
8487                                                           /* 33222222222211111111110000000000
8488                                                              10987654321098765432109876543210
8489                                                              010001x0101xxxxx0110xxxxxxxxxxxx
8490                                                              cmla.  */
8491                                                           return 2076;
8492                                                         }
8493                                                       else
8494                                                         {
8495                                                           /* 33222222222211111111110000000000
8496                                                              10987654321098765432109876543210
8497                                                              010001x0111xxxxx0110xxxxxxxxxxxx
8498                                                              cmla.  */
8499                                                           return 2077;
8500                                                         }
8501                                                     }
8502                                                   else
8503                                                     {
8504                                                       if (((word >> 22) & 0x1) == 0)
8505                                                         {
8506                                                           /* 33222222222211111111110000000000
8507                                                              10987654321098765432109876543210
8508                                                              010001x0101xxxxx0111xxxxxxxxxxxx
8509                                                              sqrdcmlah.  */
8510                                                           return 2205;
8511                                                         }
8512                                                       else
8513                                                         {
8514                                                           /* 33222222222211111111110000000000
8515                                                              10987654321098765432109876543210
8516                                                              010001x0111xxxxx0111xxxxxxxxxxxx
8517                                                              sqrdcmlah.  */
8518                                                           return 2206;
8519                                                         }
8520                                                     }
8521                                                 }
8522                                               else
8523                                                 {
8524                                                   /* 33222222222211111111110000000000
8525                                                      10987654321098765432109876543210
8526                                                      110001x01x1xxxxx011xxxxxxxxxxxxx
8527                                                      ldff1h.  */
8528                                                   return 1669;
8529                                                 }
8530                                             }
8531                                         }
8532                                     }
8533                                 }
8534                               else
8535                                 {
8536                                   if (((word >> 30) & 0x1) == 0)
8537                                     {
8538                                       if (((word >> 31) & 0x1) == 0)
8539                                         {
8540                                           if (((word >> 21) & 0x1) == 0)
8541                                             {
8542                                               /* 33222222222211111111110000000000
8543                                                  10987654321098765432109876543210
8544                                                  000001x0xx0xxxxx111xxxxxxxxxxxxx
8545                                                  msb.  */
8546                                               return 1759;
8547                                             }
8548                                           else
8549                                             {
8550                                               if (((word >> 10) & 0x1) == 0)
8551                                                 {
8552                                                   if (((word >> 11) & 0x1) == 0)
8553                                                     {
8554                                                       if (((word >> 12) & 0x1) == 0)
8555                                                         {
8556                                                           if (((word >> 20) & 0x1) == 0)
8557                                                             {
8558                                                               if (((word >> 22) & 0x1) == 0)
8559                                                                 {
8560                                                                   if (((word >> 23) & 0x1) == 0)
8561                                                                     {
8562                                                                       /* 33222222222211111111110000000000
8563                                                                          10987654321098765432109876543210
8564                                                                          000001x00010xxxx111000xxxxxxxxxx
8565                                                                          cntb.  */
8566                                                                       return 1361;
8567                                                                     }
8568                                                                   else
8569                                                                     {
8570                                                                       /* 33222222222211111111110000000000
8571                                                                          10987654321098765432109876543210
8572                                                                          000001x01010xxxx111000xxxxxxxxxx
8573                                                                          cntw.  */
8574                                                                       return 1365;
8575                                                                     }
8576                                                                 }
8577                                                               else
8578                                                                 {
8579                                                                   if (((word >> 23) & 0x1) == 0)
8580                                                                     {
8581                                                                       /* 33222222222211111111110000000000
8582                                                                          10987654321098765432109876543210
8583                                                                          000001x00110xxxx111000xxxxxxxxxx
8584                                                                          cnth.  */
8585                                                                       return 1363;
8586                                                                     }
8587                                                                   else
8588                                                                     {
8589                                                                       /* 33222222222211111111110000000000
8590                                                                          10987654321098765432109876543210
8591                                                                          000001x01110xxxx111000xxxxxxxxxx
8592                                                                          cntd.  */
8593                                                                       return 1362;
8594                                                                     }
8595                                                                 }
8596                                                             }
8597                                                           else
8598                                                             {
8599                                                               if (((word >> 22) & 0x1) == 0)
8600                                                                 {
8601                                                                   if (((word >> 23) & 0x1) == 0)
8602                                                                     {
8603                                                                       /* 33222222222211111111110000000000
8604                                                                          10987654321098765432109876543210
8605                                                                          000001x00011xxxx111000xxxxxxxxxx
8606                                                                          incb.  */
8607                                                                       return 1497;
8608                                                                     }
8609                                                                   else
8610                                                                     {
8611                                                                       /* 33222222222211111111110000000000
8612                                                                          10987654321098765432109876543210
8613                                                                          000001x01011xxxx111000xxxxxxxxxx
8614                                                                          incw.  */
8615                                                                       return 1505;
8616                                                                     }
8617                                                                 }
8618                                                               else
8619                                                                 {
8620                                                                   if (((word >> 23) & 0x1) == 0)
8621                                                                     {
8622                                                                       /* 33222222222211111111110000000000
8623                                                                          10987654321098765432109876543210
8624                                                                          000001x00111xxxx111000xxxxxxxxxx
8625                                                                          inch.  */
8626                                                                       return 1501;
8627                                                                     }
8628                                                                   else
8629                                                                     {
8630                                                                       /* 33222222222211111111110000000000
8631                                                                          10987654321098765432109876543210
8632                                                                          000001x01111xxxx111000xxxxxxxxxx
8633                                                                          incd.  */
8634                                                                       return 1499;
8635                                                                     }
8636                                                                 }
8637                                                             }
8638                                                         }
8639                                                       else
8640                                                         {
8641                                                           if (((word >> 20) & 0x1) == 0)
8642                                                             {
8643                                                               if (((word >> 22) & 0x1) == 0)
8644                                                                 {
8645                                                                   if (((word >> 23) & 0x1) == 0)
8646                                                                     {
8647                                                                       /* 33222222222211111111110000000000
8648                                                                          10987654321098765432109876543210
8649                                                                          000001x00010xxxx111100xxxxxxxxxx
8650                                                                          sqincb.  */
8651                                                                       return 1864;
8652                                                                     }
8653                                                                   else
8654                                                                     {
8655                                                                       /* 33222222222211111111110000000000
8656                                                                          10987654321098765432109876543210
8657                                                                          000001x01010xxxx111100xxxxxxxxxx
8658                                                                          sqincw.  */
8659                                                                       return 1876;
8660                                                                     }
8661                                                                 }
8662                                                               else
8663                                                                 {
8664                                                                   if (((word >> 23) & 0x1) == 0)
8665                                                                     {
8666                                                                       /* 33222222222211111111110000000000
8667                                                                          10987654321098765432109876543210
8668                                                                          000001x00110xxxx111100xxxxxxxxxx
8669                                                                          sqinch.  */
8670                                                                       return 1870;
8671                                                                     }
8672                                                                   else
8673                                                                     {
8674                                                                       /* 33222222222211111111110000000000
8675                                                                          10987654321098765432109876543210
8676                                                                          000001x01110xxxx111100xxxxxxxxxx
8677                                                                          sqincd.  */
8678                                                                       return 1867;
8679                                                                     }
8680                                                                 }
8681                                                             }
8682                                                           else
8683                                                             {
8684                                                               if (((word >> 22) & 0x1) == 0)
8685                                                                 {
8686                                                                   if (((word >> 23) & 0x1) == 0)
8687                                                                     {
8688                                                                       /* 33222222222211111111110000000000
8689                                                                          10987654321098765432109876543210
8690                                                                          000001x00011xxxx111100xxxxxxxxxx
8691                                                                          sqincb.  */
8692                                                                       return 1863;
8693                                                                     }
8694                                                                   else
8695                                                                     {
8696                                                                       /* 33222222222211111111110000000000
8697                                                                          10987654321098765432109876543210
8698                                                                          000001x01011xxxx111100xxxxxxxxxx
8699                                                                          sqincw.  */
8700                                                                       return 1875;
8701                                                                     }
8702                                                                 }
8703                                                               else
8704                                                                 {
8705                                                                   if (((word >> 23) & 0x1) == 0)
8706                                                                     {
8707                                                                       /* 33222222222211111111110000000000
8708                                                                          10987654321098765432109876543210
8709                                                                          000001x00111xxxx111100xxxxxxxxxx
8710                                                                          sqinch.  */
8711                                                                       return 1869;
8712                                                                     }
8713                                                                   else
8714                                                                     {
8715                                                                       /* 33222222222211111111110000000000
8716                                                                          10987654321098765432109876543210
8717                                                                          000001x01111xxxx111100xxxxxxxxxx
8718                                                                          sqincd.  */
8719                                                                       return 1866;
8720                                                                     }
8721                                                                 }
8722                                                             }
8723                                                         }
8724                                                     }
8725                                                   else
8726                                                     {
8727                                                       if (((word >> 20) & 0x1) == 0)
8728                                                         {
8729                                                           if (((word >> 22) & 0x1) == 0)
8730                                                             {
8731                                                               if (((word >> 23) & 0x1) == 0)
8732                                                                 {
8733                                                                   /* 33222222222211111111110000000000
8734                                                                      10987654321098765432109876543210
8735                                                                      000001x00010xxxx111x10xxxxxxxxxx
8736                                                                      sqdecb.  */
8737                                                                   return 1850;
8738                                                                 }
8739                                                               else
8740                                                                 {
8741                                                                   /* 33222222222211111111110000000000
8742                                                                      10987654321098765432109876543210
8743                                                                      000001x01010xxxx111x10xxxxxxxxxx
8744                                                                      sqdecw.  */
8745                                                                   return 1862;
8746                                                                 }
8747                                                             }
8748                                                           else
8749                                                             {
8750                                                               if (((word >> 23) & 0x1) == 0)
8751                                                                 {
8752                                                                   /* 33222222222211111111110000000000
8753                                                                      10987654321098765432109876543210
8754                                                                      000001x00110xxxx111x10xxxxxxxxxx
8755                                                                      sqdech.  */
8756                                                                   return 1856;
8757                                                                 }
8758                                                               else
8759                                                                 {
8760                                                                   /* 33222222222211111111110000000000
8761                                                                      10987654321098765432109876543210
8762                                                                      000001x01110xxxx111x10xxxxxxxxxx
8763                                                                      sqdecd.  */
8764                                                                   return 1853;
8765                                                                 }
8766                                                             }
8767                                                         }
8768                                                       else
8769                                                         {
8770                                                           if (((word >> 22) & 0x1) == 0)
8771                                                             {
8772                                                               if (((word >> 23) & 0x1) == 0)
8773                                                                 {
8774                                                                   /* 33222222222211111111110000000000
8775                                                                      10987654321098765432109876543210
8776                                                                      000001x00011xxxx111x10xxxxxxxxxx
8777                                                                      sqdecb.  */
8778                                                                   return 1849;
8779                                                                 }
8780                                                               else
8781                                                                 {
8782                                                                   /* 33222222222211111111110000000000
8783                                                                      10987654321098765432109876543210
8784                                                                      000001x01011xxxx111x10xxxxxxxxxx
8785                                                                      sqdecw.  */
8786                                                                   return 1861;
8787                                                                 }
8788                                                             }
8789                                                           else
8790                                                             {
8791                                                               if (((word >> 23) & 0x1) == 0)
8792                                                                 {
8793                                                                   /* 33222222222211111111110000000000
8794                                                                      10987654321098765432109876543210
8795                                                                      000001x00111xxxx111x10xxxxxxxxxx
8796                                                                      sqdech.  */
8797                                                                   return 1855;
8798                                                                 }
8799                                                               else
8800                                                                 {
8801                                                                   /* 33222222222211111111110000000000
8802                                                                      10987654321098765432109876543210
8803                                                                      000001x01111xxxx111x10xxxxxxxxxx
8804                                                                      sqdecd.  */
8805                                                                   return 1852;
8806                                                                 }
8807                                                             }
8808                                                         }
8809                                                     }
8810                                                 }
8811                                               else
8812                                                 {
8813                                                   if (((word >> 11) & 0x1) == 0)
8814                                                     {
8815                                                       if (((word >> 12) & 0x1) == 0)
8816                                                         {
8817                                                           if (((word >> 22) & 0x1) == 0)
8818                                                             {
8819                                                               if (((word >> 23) & 0x1) == 0)
8820                                                                 {
8821                                                                   /* 33222222222211111111110000000000
8822                                                                      10987654321098765432109876543210
8823                                                                      000001x0001xxxxx111001xxxxxxxxxx
8824                                                                      decb.  */
8825                                                                   return 1372;
8826                                                                 }
8827                                                               else
8828                                                                 {
8829                                                                   /* 33222222222211111111110000000000
8830                                                                      10987654321098765432109876543210
8831                                                                      000001x0101xxxxx111001xxxxxxxxxx
8832                                                                      decw.  */
8833                                                                   return 1380;
8834                                                                 }
8835                                                             }
8836                                                           else
8837                                                             {
8838                                                               if (((word >> 23) & 0x1) == 0)
8839                                                                 {
8840                                                                   /* 33222222222211111111110000000000
8841                                                                      10987654321098765432109876543210
8842                                                                      000001x0011xxxxx111001xxxxxxxxxx
8843                                                                      dech.  */
8844                                                                   return 1376;
8845                                                                 }
8846                                                               else
8847                                                                 {
8848                                                                   /* 33222222222211111111110000000000
8849                                                                      10987654321098765432109876543210
8850                                                                      000001x0111xxxxx111001xxxxxxxxxx
8851                                                                      decd.  */
8852                                                                   return 1374;
8853                                                                 }
8854                                                             }
8855                                                         }
8856                                                       else
8857                                                         {
8858                                                           if (((word >> 20) & 0x1) == 0)
8859                                                             {
8860                                                               if (((word >> 22) & 0x1) == 0)
8861                                                                 {
8862                                                                   if (((word >> 23) & 0x1) == 0)
8863                                                                     {
8864                                                                       /* 33222222222211111111110000000000
8865                                                                          10987654321098765432109876543210
8866                                                                          000001x00010xxxx111101xxxxxxxxxx
8867                                                                          uqincb.  */
8868                                                                       return 2011;
8869                                                                     }
8870                                                                   else
8871                                                                     {
8872                                                                       /* 33222222222211111111110000000000
8873                                                                          10987654321098765432109876543210
8874                                                                          000001x01010xxxx111101xxxxxxxxxx
8875                                                                          uqincw.  */
8876                                                                       return 2023;
8877                                                                     }
8878                                                                 }
8879                                                               else
8880                                                                 {
8881                                                                   if (((word >> 23) & 0x1) == 0)
8882                                                                     {
8883                                                                       /* 33222222222211111111110000000000
8884                                                                          10987654321098765432109876543210
8885                                                                          000001x00110xxxx111101xxxxxxxxxx
8886                                                                          uqinch.  */
8887                                                                       return 2017;
8888                                                                     }
8889                                                                   else
8890                                                                     {
8891                                                                       /* 33222222222211111111110000000000
8892                                                                          10987654321098765432109876543210
8893                                                                          000001x01110xxxx111101xxxxxxxxxx
8894                                                                          uqincd.  */
8895                                                                       return 2014;
8896                                                                     }
8897                                                                 }
8898                                                             }
8899                                                           else
8900                                                             {
8901                                                               if (((word >> 22) & 0x1) == 0)
8902                                                                 {
8903                                                                   if (((word >> 23) & 0x1) == 0)
8904                                                                     {
8905                                                                       /* 33222222222211111111110000000000
8906                                                                          10987654321098765432109876543210
8907                                                                          000001x00011xxxx111101xxxxxxxxxx
8908                                                                          uqincb.  */
8909                                                                       return 2012;
8910                                                                     }
8911                                                                   else
8912                                                                     {
8913                                                                       /* 33222222222211111111110000000000
8914                                                                          10987654321098765432109876543210
8915                                                                          000001x01011xxxx111101xxxxxxxxxx
8916                                                                          uqincw.  */
8917                                                                       return 2024;
8918                                                                     }
8919                                                                 }
8920                                                               else
8921                                                                 {
8922                                                                   if (((word >> 23) & 0x1) == 0)
8923                                                                     {
8924                                                                       /* 33222222222211111111110000000000
8925                                                                          10987654321098765432109876543210
8926                                                                          000001x00111xxxx111101xxxxxxxxxx
8927                                                                          uqinch.  */
8928                                                                       return 2018;
8929                                                                     }
8930                                                                   else
8931                                                                     {
8932                                                                       /* 33222222222211111111110000000000
8933                                                                          10987654321098765432109876543210
8934                                                                          000001x01111xxxx111101xxxxxxxxxx
8935                                                                          uqincd.  */
8936                                                                       return 2015;
8937                                                                     }
8938                                                                 }
8939                                                             }
8940                                                         }
8941                                                     }
8942                                                   else
8943                                                     {
8944                                                       if (((word >> 20) & 0x1) == 0)
8945                                                         {
8946                                                           if (((word >> 22) & 0x1) == 0)
8947                                                             {
8948                                                               if (((word >> 23) & 0x1) == 0)
8949                                                                 {
8950                                                                   /* 33222222222211111111110000000000
8951                                                                      10987654321098765432109876543210
8952                                                                      000001x00010xxxx111x11xxxxxxxxxx
8953                                                                      uqdecb.  */
8954                                                                   return 1997;
8955                                                                 }
8956                                                               else
8957                                                                 {
8958                                                                   /* 33222222222211111111110000000000
8959                                                                      10987654321098765432109876543210
8960                                                                      000001x01010xxxx111x11xxxxxxxxxx
8961                                                                      uqdecw.  */
8962                                                                   return 2009;
8963                                                                 }
8964                                                             }
8965                                                           else
8966                                                             {
8967                                                               if (((word >> 23) & 0x1) == 0)
8968                                                                 {
8969                                                                   /* 33222222222211111111110000000000
8970                                                                      10987654321098765432109876543210
8971                                                                      000001x00110xxxx111x11xxxxxxxxxx
8972                                                                      uqdech.  */
8973                                                                   return 2003;
8974                                                                 }
8975                                                               else
8976                                                                 {
8977                                                                   /* 33222222222211111111110000000000
8978                                                                      10987654321098765432109876543210
8979                                                                      000001x01110xxxx111x11xxxxxxxxxx
8980                                                                      uqdecd.  */
8981                                                                   return 2000;
8982                                                                 }
8983                                                             }
8984                                                         }
8985                                                       else
8986                                                         {
8987                                                           if (((word >> 22) & 0x1) == 0)
8988                                                             {
8989                                                               if (((word >> 23) & 0x1) == 0)
8990                                                                 {
8991                                                                   /* 33222222222211111111110000000000
8992                                                                      10987654321098765432109876543210
8993                                                                      000001x00011xxxx111x11xxxxxxxxxx
8994                                                                      uqdecb.  */
8995                                                                   return 1998;
8996                                                                 }
8997                                                               else
8998                                                                 {
8999                                                                   /* 33222222222211111111110000000000
9000                                                                      10987654321098765432109876543210
9001                                                                      000001x01011xxxx111x11xxxxxxxxxx
9002                                                                      uqdecw.  */
9003                                                                   return 2010;
9004                                                                 }
9005                                                             }
9006                                                           else
9007                                                             {
9008                                                               if (((word >> 23) & 0x1) == 0)
9009                                                                 {
9010                                                                   /* 33222222222211111111110000000000
9011                                                                      10987654321098765432109876543210
9012                                                                      000001x00111xxxx111x11xxxxxxxxxx
9013                                                                      uqdech.  */
9014                                                                   return 2004;
9015                                                                 }
9016                                                               else
9017                                                                 {
9018                                                                   /* 33222222222211111111110000000000
9019                                                                      10987654321098765432109876543210
9020                                                                      000001x01111xxxx111x11xxxxxxxxxx
9021                                                                      uqdecd.  */
9022                                                                   return 2001;
9023                                                                 }
9024                                                             }
9025                                                         }
9026                                                     }
9027                                                 }
9028                                             }
9029                                         }
9030                                       else
9031                                         {
9032                                           if (((word >> 22) & 0x1) == 0)
9033                                             {
9034                                               if (((word >> 21) & 0x1) == 0)
9035                                                 {
9036                                                   if (((word >> 23) & 0x1) == 0)
9037                                                     {
9038                                                       /* 33222222222211111111110000000000
9039                                                          10987654321098765432109876543210
9040                                                          100001x0000xxxxx111xxxxxxxxxxxxx
9041                                                          prfb.  */
9042                                                       return 1783;
9043                                                     }
9044                                                   else
9045                                                     {
9046                                                       /* 33222222222211111111110000000000
9047                                                          10987654321098765432109876543210
9048                                                          100001x0100xxxxx111xxxxxxxxxxxxx
9049                                                          prfh.  */
9050                                                       return 1797;
9051                                                     }
9052                                                 }
9053                                               else
9054                                                 {
9055                                                   if (((word >> 23) & 0x1) == 0)
9056                                                     {
9057                                                       /* 33222222222211111111110000000000
9058                                                          10987654321098765432109876543210
9059                                                          100001x0001xxxxx111xxxxxxxxxxxxx
9060                                                          ldff1b.  */
9061                                                       return 1651;
9062                                                     }
9063                                                   else
9064                                                     {
9065                                                       /* 33222222222211111111110000000000
9066                                                          10987654321098765432109876543210
9067                                                          100001x0101xxxxx111xxxxxxxxxxxxx
9068                                                          ldff1h.  */
9069                                                       return 1672;
9070                                                     }
9071                                                 }
9072                                             }
9073                                           else
9074                                             {
9075                                               if (((word >> 23) & 0x1) == 0)
9076                                                 {
9077                                                   /* 33222222222211111111110000000000
9078                                                      10987654321098765432109876543210
9079                                                      100001x001xxxxxx111xxxxxxxxxxxxx
9080                                                      ld1rb.  */
9081                                                   return 1553;
9082                                                 }
9083                                               else
9084                                                 {
9085                                                   /* 33222222222211111111110000000000
9086                                                      10987654321098765432109876543210
9087                                                      100001x011xxxxxx111xxxxxxxxxxxxx
9088                                                      ld1rh.  */
9089                                                   return 1557;
9090                                                 }
9091                                             }
9092                                         }
9093                                     }
9094                                   else
9095                                     {
9096                                       if (((word >> 21) & 0x1) == 0)
9097                                         {
9098                                           if (((word >> 22) & 0x1) == 0)
9099                                             {
9100                                               if (((word >> 23) & 0x1) == 0)
9101                                                 {
9102                                                   /* 33222222222211111111110000000000
9103                                                      10987654321098765432109876543210
9104                                                      x10001x0000xxxxx111xxxxxxxxxxxxx
9105                                                      prfb.  */
9106                                                   return 1785;
9107                                                 }
9108                                               else
9109                                                 {
9110                                                   /* 33222222222211111111110000000000
9111                                                      10987654321098765432109876543210
9112                                                      x10001x0100xxxxx111xxxxxxxxxxxxx
9113                                                      prfh.  */
9114                                                   return 1799;
9115                                                 }
9116                                             }
9117                                           else
9118                                             {
9119                                               if (((word >> 23) & 0x1) == 0)
9120                                                 {
9121                                                   /* 33222222222211111111110000000000
9122                                                      10987654321098765432109876543210
9123                                                      x10001x0010xxxxx111xxxxxxxxxxxxx
9124                                                      ldff1b.  */
9125                                                   return 1650;
9126                                                 }
9127                                               else
9128                                                 {
9129                                                   /* 33222222222211111111110000000000
9130                                                      10987654321098765432109876543210
9131                                                      x10001x0110xxxxx111xxxxxxxxxxxxx
9132                                                      ldff1h.  */
9133                                                   return 1670;
9134                                                 }
9135                                             }
9136                                         }
9137                                       else
9138                                         {
9139                                           if (((word >> 23) & 0x1) == 0)
9140                                             {
9141                                               if (((word >> 31) & 0x1) == 0)
9142                                                 {
9143                                                   if (((word >> 10) & 0x1) == 0)
9144                                                     {
9145                                                       if (((word >> 11) & 0x1) == 0)
9146                                                         {
9147                                                           /* 33222222222211111111110000000000
9148                                                              10987654321098765432109876543210
9149                                                              010001x00x1xxxxx111x00xxxxxxxxxx
9150                                                              sqdmulh.  */
9151                                                           return 2194;
9152                                                         }
9153                                                       else
9154                                                         {
9155                                                           /* 33222222222211111111110000000000
9156                                                              10987654321098765432109876543210
9157                                                              010001x00x1xxxxx111x10xxxxxxxxxx
9158                                                              mul.  */
9159                                                           return 2121;
9160                                                         }
9161                                                     }
9162                                                   else
9163                                                     {
9164                                                       /* 33222222222211111111110000000000
9165                                                          10987654321098765432109876543210
9166                                                          010001x00x1xxxxx111xx1xxxxxxxxxx
9167                                                          sqrdmulh.  */
9168                                                       return 2216;
9169                                                     }
9170                                                 }
9171                                               else
9172                                                 {
9173                                                   if (((word >> 22) & 0x1) == 0)
9174                                                     {
9175                                                       /* 33222222222211111111110000000000
9176                                                          10987654321098765432109876543210
9177                                                          110001x0001xxxxx111xxxxxxxxxxxxx
9178                                                          ldff1b.  */
9179                                                       return 1652;
9180                                                     }
9181                                                   else
9182                                                     {
9183                                                       /* 33222222222211111111110000000000
9184                                                          10987654321098765432109876543210
9185                                                          110001x0011xxxxx111xxxxxxxxxxxxx
9186                                                          prfd.  */
9187                                                       return 1789;
9188                                                     }
9189                                                 }
9190                                             }
9191                                           else
9192                                             {
9193                                               if (((word >> 22) & 0x1) == 0)
9194                                                 {
9195                                                   if (((word >> 31) & 0x1) == 0)
9196                                                     {
9197                                                       if (((word >> 10) & 0x1) == 0)
9198                                                         {
9199                                                           if (((word >> 12) & 0x1) == 0)
9200                                                             {
9201                                                               /* 33222222222211111111110000000000
9202                                                                  10987654321098765432109876543210
9203                                                                  010001x0101xxxxx1110x0xxxxxxxxxx
9204                                                                  sqdmullb.  */
9205                                                               return 2198;
9206                                                             }
9207                                                           else
9208                                                             {
9209                                                               if (((word >> 11) & 0x1) == 0)
9210                                                                 {
9211                                                                   /* 33222222222211111111110000000000
9212                                                                      10987654321098765432109876543210
9213                                                                      010001x0101xxxxx111100xxxxxxxxxx
9214                                                                      sqdmulh.  */
9215                                                                   return 2195;
9216                                                                 }
9217                                                               else
9218                                                                 {
9219                                                                   /* 33222222222211111111110000000000
9220                                                                      10987654321098765432109876543210
9221                                                                      010001x0101xxxxx111110xxxxxxxxxx
9222                                                                      mul.  */
9223                                                                   return 2122;
9224                                                                 }
9225                                                             }
9226                                                         }
9227                                                       else
9228                                                         {
9229                                                           if (((word >> 12) & 0x1) == 0)
9230                                                             {
9231                                                               /* 33222222222211111111110000000000
9232                                                                  10987654321098765432109876543210
9233                                                                  010001x0101xxxxx1110x1xxxxxxxxxx
9234                                                                  sqdmullt.  */
9235                                                               return 2201;
9236                                                             }
9237                                                           else
9238                                                             {
9239                                                               /* 33222222222211111111110000000000
9240                                                                  10987654321098765432109876543210
9241                                                                  010001x0101xxxxx1111x1xxxxxxxxxx
9242                                                                  sqrdmulh.  */
9243                                                               return 2217;
9244                                                             }
9245                                                         }
9246                                                     }
9247                                                   else
9248                                                     {
9249                                                       /* 33222222222211111111110000000000
9250                                                          10987654321098765432109876543210
9251                                                          110001x0101xxxxx111xxxxxxxxxxxxx
9252                                                          ldff1h.  */
9253                                                       return 1673;
9254                                                     }
9255                                                 }
9256                                               else
9257                                                 {
9258                                                   if (((word >> 31) & 0x1) == 0)
9259                                                     {
9260                                                       if (((word >> 10) & 0x1) == 0)
9261                                                         {
9262                                                           if (((word >> 12) & 0x1) == 0)
9263                                                             {
9264                                                               /* 33222222222211111111110000000000
9265                                                                  10987654321098765432109876543210
9266                                                                  010001x0111xxxxx1110x0xxxxxxxxxx
9267                                                                  sqdmullb.  */
9268                                                               return 2199;
9269                                                             }
9270                                                           else
9271                                                             {
9272                                                               if (((word >> 11) & 0x1) == 0)
9273                                                                 {
9274                                                                   /* 33222222222211111111110000000000
9275                                                                      10987654321098765432109876543210
9276                                                                      010001x0111xxxxx111100xxxxxxxxxx
9277                                                                      sqdmulh.  */
9278                                                                   return 2196;
9279                                                                 }
9280                                                               else
9281                                                                 {
9282                                                                   /* 33222222222211111111110000000000
9283                                                                      10987654321098765432109876543210
9284                                                                      010001x0111xxxxx111110xxxxxxxxxx
9285                                                                      mul.  */
9286                                                                   return 2123;
9287                                                                 }
9288                                                             }
9289                                                         }
9290                                                       else
9291                                                         {
9292                                                           if (((word >> 12) & 0x1) == 0)
9293                                                             {
9294                                                               /* 33222222222211111111110000000000
9295                                                                  10987654321098765432109876543210
9296                                                                  010001x0111xxxxx1110x1xxxxxxxxxx
9297                                                                  sqdmullt.  */
9298                                                               return 2202;
9299                                                             }
9300                                                           else
9301                                                             {
9302                                                               /* 33222222222211111111110000000000
9303                                                                  10987654321098765432109876543210
9304                                                                  010001x0111xxxxx1111x1xxxxxxxxxx
9305                                                                  sqrdmulh.  */
9306                                                               return 2218;
9307                                                             }
9308                                                         }
9309                                                     }
9310                                                   else
9311                                                     {
9312                                                       /* 33222222222211111111110000000000
9313                                                          10987654321098765432109876543210
9314                                                          110001x0111xxxxx111xxxxxxxxxxxxx
9315                                                          ldff1h.  */
9316                                                       return 1671;
9317                                                     }
9318                                                 }
9319                                             }
9320                                         }
9321                                     }
9322                                 }
9323                             }
9324                         }
9325                     }
9326                   else
9327                     {
9328                       if (((word >> 21) & 0x1) == 0)
9329                         {
9330                           if (((word >> 15) & 0x1) == 0)
9331                             {
9332                               if (((word >> 30) & 0x1) == 0)
9333                                 {
9334                                   if (((word >> 13) & 0x1) == 0)
9335                                     {
9336                                       if (((word >> 14) & 0x1) == 0)
9337                                         {
9338                                           if (((word >> 31) & 0x1) == 0)
9339                                             {
9340                                               if (((word >> 4) & 0x1) == 0)
9341                                                 {
9342                                                   /* 33222222222211111111110000000000
9343                                                      10987654321098765432109876543210
9344                                                      001001x0xx0xxxxx000xxxxxxxx0xxxx
9345                                                      cmphs.  */
9346                                                   return 1345;
9347                                                 }
9348                                               else
9349                                                 {
9350                                                   /* 33222222222211111111110000000000
9351                                                      10987654321098765432109876543210
9352                                                      001001x0xx0xxxxx000xxxxxxxx1xxxx
9353                                                      cmphi.  */
9354                                                   return 1342;
9355                                                 }
9356                                             }
9357                                           else
9358                                             {
9359                                               if (((word >> 23) & 0x1) == 0)
9360                                                 {
9361                                                   /* 33222222222211111111110000000000
9362                                                      10987654321098765432109876543210
9363                                                      101001x00x0xxxxx000xxxxxxxxxxxxx
9364                                                      ld1rqb.  */
9365                                                   return 1559;
9366                                                 }
9367                                               else
9368                                                 {
9369                                                   /* 33222222222211111111110000000000
9370                                                      10987654321098765432109876543210
9371                                                      101001x01x0xxxxx000xxxxxxxxxxxxx
9372                                                      ld1rqh.  */
9373                                                   return 1563;
9374                                                 }
9375                                             }
9376                                         }
9377                                       else
9378                                         {
9379                                           if (((word >> 31) & 0x1) == 0)
9380                                             {
9381                                               if (((word >> 4) & 0x1) == 0)
9382                                                 {
9383                                                   /* 33222222222211111111110000000000
9384                                                      10987654321098765432109876543210
9385                                                      001001x0xx0xxxxx010xxxxxxxx0xxxx
9386                                                      cmpge.  */
9387                                                   return 1336;
9388                                                 }
9389                                               else
9390                                                 {
9391                                                   /* 33222222222211111111110000000000
9392                                                      10987654321098765432109876543210
9393                                                      001001x0xx0xxxxx010xxxxxxxx1xxxx
9394                                                      cmpgt.  */
9395                                                   return 1339;
9396                                                 }
9397                                             }
9398                                           else
9399                                             {
9400                                               if (((word >> 22) & 0x1) == 0)
9401                                                 {
9402                                                   if (((word >> 23) & 0x1) == 0)
9403                                                     {
9404                                                       /* 33222222222211111111110000000000
9405                                                          10987654321098765432109876543210
9406                                                          101001x0000xxxxx010xxxxxxxxxxxxx
9407                                                          ld1b.  */
9408                                                       return 1517;
9409                                                     }
9410                                                   else
9411                                                     {
9412                                                       /* 33222222222211111111110000000000
9413                                                          10987654321098765432109876543210
9414                                                          101001x0100xxxxx010xxxxxxxxxxxxx
9415                                                          ld1sw.  */
9416                                                       return 1597;
9417                                                     }
9418                                                 }
9419                                               else
9420                                                 {
9421                                                   if (((word >> 23) & 0x1) == 0)
9422                                                     {
9423                                                       /* 33222222222211111111110000000000
9424                                                          10987654321098765432109876543210
9425                                                          101001x0010xxxxx010xxxxxxxxxxxxx
9426                                                          ld1b.  */
9427                                                       return 1519;
9428                                                     }
9429                                                   else
9430                                                     {
9431                                                       /* 33222222222211111111110000000000
9432                                                          10987654321098765432109876543210
9433                                                          101001x0110xxxxx010xxxxxxxxxxxxx
9434                                                          ld1h.  */
9435                                                       return 1539;
9436                                                     }
9437                                                 }
9438                                             }
9439                                         }
9440                                     }
9441                                   else
9442                                     {
9443                                       if (((word >> 14) & 0x1) == 0)
9444                                         {
9445                                           if (((word >> 31) & 0x1) == 0)
9446                                             {
9447                                               if (((word >> 4) & 0x1) == 0)
9448                                                 {
9449                                                   /* 33222222222211111111110000000000
9450                                                      10987654321098765432109876543210
9451                                                      001001x0xx0xxxxx001xxxxxxxx0xxxx
9452                                                      cmpeq.  */
9453                                                   return 1333;
9454                                                 }
9455                                               else
9456                                                 {
9457                                                   /* 33222222222211111111110000000000
9458                                                      10987654321098765432109876543210
9459                                                      001001x0xx0xxxxx001xxxxxxxx1xxxx
9460                                                      cmpne.  */
9461                                                   return 1356;
9462                                                 }
9463                                             }
9464                                           else
9465                                             {
9466                                               if (((word >> 23) & 0x1) == 0)
9467                                                 {
9468                                                   /* 33222222222211111111110000000000
9469                                                      10987654321098765432109876543210
9470                                                      101001x00x0xxxxx001xxxxxxxxxxxxx
9471                                                      ld1rqb.  */
9472                                                   return 1558;
9473                                                 }
9474                                               else
9475                                                 {
9476                                                   /* 33222222222211111111110000000000
9477                                                      10987654321098765432109876543210
9478                                                      101001x01x0xxxxx001xxxxxxxxxxxxx
9479                                                      ld1rqh.  */
9480                                                   return 1562;
9481                                                 }
9482                                             }
9483                                         }
9484                                       else
9485                                         {
9486                                           if (((word >> 31) & 0x1) == 0)
9487                                             {
9488                                               if (((word >> 4) & 0x1) == 0)
9489                                                 {
9490                                                   /* 33222222222211111111110000000000
9491                                                      10987654321098765432109876543210
9492                                                      001001x0xx0xxxxx011xxxxxxxx0xxxx
9493                                                      cmplt.  */
9494                                                   return 1354;
9495                                                 }
9496                                               else
9497                                                 {
9498                                                   /* 33222222222211111111110000000000
9499                                                      10987654321098765432109876543210
9500                                                      001001x0xx0xxxxx011xxxxxxxx1xxxx
9501                                                      cmple.  */
9502                                                   return 1348;
9503                                                 }
9504                                             }
9505                                           else
9506                                             {
9507                                               if (((word >> 22) & 0x1) == 0)
9508                                                 {
9509                                                   if (((word >> 23) & 0x1) == 0)
9510                                                     {
9511                                                       /* 33222222222211111111110000000000
9512                                                          10987654321098765432109876543210
9513                                                          101001x0000xxxxx011xxxxxxxxxxxxx
9514                                                          ldff1b.  */
9515                                                       return 1641;
9516                                                     }
9517                                                   else
9518                                                     {
9519                                                       /* 33222222222211111111110000000000
9520                                                          10987654321098765432109876543210
9521                                                          101001x0100xxxxx011xxxxxxxxxxxxx
9522                                                          ldff1sw.  */
9523                                                       return 1697;
9524                                                     }
9525                                                 }
9526                                               else
9527                                                 {
9528                                                   if (((word >> 23) & 0x1) == 0)
9529                                                     {
9530                                                       /* 33222222222211111111110000000000
9531                                                          10987654321098765432109876543210
9532                                                          101001x0010xxxxx011xxxxxxxxxxxxx
9533                                                          ldff1b.  */
9534                                                       return 1645;
9535                                                     }
9536                                                   else
9537                                                     {
9538                                                       /* 33222222222211111111110000000000
9539                                                          10987654321098765432109876543210
9540                                                          101001x0110xxxxx011xxxxxxxxxxxxx
9541                                                          ldff1h.  */
9542                                                       return 1664;
9543                                                     }
9544                                                 }
9545                                             }
9546                                         }
9547                                     }
9548                                 }
9549                               else
9550                                 {
9551                                   if (((word >> 31) & 0x1) == 0)
9552                                     {
9553                                       /* 33222222222211111111110000000000
9554                                          10987654321098765432109876543210
9555                                          011001x0xx0xxxxx0xxxxxxxxxxxxxxx
9556                                          fcmla.  */
9557                                       return 1402;
9558                                     }
9559                                   else
9560                                     {
9561                                       if (((word >> 13) & 0x1) == 0)
9562                                         {
9563                                           if (((word >> 22) & 0x1) == 0)
9564                                             {
9565                                               /* 33222222222211111111110000000000
9566                                                  10987654321098765432109876543210
9567                                                  111001x0x00xxxxx0x0xxxxxxxxxxxxx
9568                                                  st1b.  */
9569                                               return 1879;
9570                                             }
9571                                           else
9572                                             {
9573                                               if (((word >> 23) & 0x1) == 0)
9574                                                 {
9575                                                   /* 33222222222211111111110000000000
9576                                                      10987654321098765432109876543210
9577                                                      111001x0010xxxxx0x0xxxxxxxxxxxxx
9578                                                      st1b.  */
9579                                                   return 1883;
9580                                                 }
9581                                               else
9582                                                 {
9583                                                   /* 33222222222211111111110000000000
9584                                                      10987654321098765432109876543210
9585                                                      111001x0110xxxxx0x0xxxxxxxxxxxxx
9586                                                      st1h.  */
9587                                                   return 1904;
9588                                                 }
9589                                             }
9590                                         }
9591                                       else
9592                                         {
9593                                           if (((word >> 14) & 0x1) == 0)
9594                                             {
9595                                               if (((word >> 22) & 0x1) == 0)
9596                                                 {
9597                                                   if (((word >> 23) & 0x1) == 0)
9598                                                     {
9599                                                       /* 33222222222211111111110000000000
9600                                                          10987654321098765432109876543210
9601                                                          111001x0000xxxxx001xxxxxxxxxxxxx
9602                                                          stnt1b.  */
9603                                                       return 2256;
9604                                                     }
9605                                                   else
9606                                                     {
9607                                                       /* 33222222222211111111110000000000
9608                                                          10987654321098765432109876543210
9609                                                          111001x0100xxxxx001xxxxxxxxxxxxx
9610                                                          stnt1h.  */
9611                                                       return 2259;
9612                                                     }
9613                                                 }
9614                                               else
9615                                                 {
9616                                                   if (((word >> 23) & 0x1) == 0)
9617                                                     {
9618                                                       /* 33222222222211111111110000000000
9619                                                          10987654321098765432109876543210
9620                                                          111001x0010xxxxx001xxxxxxxxxxxxx
9621                                                          stnt1b.  */
9622                                                       return 2255;
9623                                                     }
9624                                                   else
9625                                                     {
9626                                                       /* 33222222222211111111110000000000
9627                                                          10987654321098765432109876543210
9628                                                          111001x0110xxxxx001xxxxxxxxxxxxx
9629                                                          stnt1h.  */
9630                                                       return 2258;
9631                                                     }
9632                                                 }
9633                                             }
9634                                           else
9635                                             {
9636                                               if (((word >> 22) & 0x1) == 0)
9637                                                 {
9638                                                   if (((word >> 23) & 0x1) == 0)
9639                                                     {
9640                                                       /* 33222222222211111111110000000000
9641                                                          10987654321098765432109876543210
9642                                                          111001x0000xxxxx011xxxxxxxxxxxxx
9643                                                          stnt1b.  */
9644                                                       return 1949;
9645                                                     }
9646                                                   else
9647                                                     {
9648                                                       /* 33222222222211111111110000000000
9649                                                          10987654321098765432109876543210
9650                                                          111001x0100xxxxx011xxxxxxxxxxxxx
9651                                                          stnt1h.  */
9652                                                       return 1953;
9653                                                     }
9654                                                 }
9655                                               else
9656                                                 {
9657                                                   if (((word >> 23) & 0x1) == 0)
9658                                                     {
9659                                                       /* 33222222222211111111110000000000
9660                                                          10987654321098765432109876543210
9661                                                          111001x0010xxxxx011xxxxxxxxxxxxx
9662                                                          st3b.  */
9663                                                       return 1933;
9664                                                     }
9665                                                   else
9666                                                     {
9667                                                       /* 33222222222211111111110000000000
9668                                                          10987654321098765432109876543210
9669                                                          111001x0110xxxxx011xxxxxxxxxxxxx
9670                                                          st3h.  */
9671                                                       return 1937;
9672                                                     }
9673                                                 }
9674                                             }
9675                                         }
9676                                     }
9677                                 }
9678                             }
9679                           else
9680                             {
9681                               if (((word >> 13) & 0x1) == 0)
9682                                 {
9683                                   if (((word >> 30) & 0x1) == 0)
9684                                     {
9685                                       if (((word >> 14) & 0x1) == 0)
9686                                         {
9687                                           if (((word >> 4) & 0x1) == 0)
9688                                             {
9689                                               /* 33222222222211111111110000000000
9690                                                  10987654321098765432109876543210
9691                                                  x01001x0xx0xxxxx100xxxxxxxx0xxxx
9692                                                  cmpge.  */
9693                                               return 1337;
9694                                             }
9695                                           else
9696                                             {
9697                                               /* 33222222222211111111110000000000
9698                                                  10987654321098765432109876543210
9699                                                  x01001x0xx0xxxxx100xxxxxxxx1xxxx
9700                                                  cmpgt.  */
9701                                               return 1340;
9702                                             }
9703                                         }
9704                                       else
9705                                         {
9706                                           if (((word >> 31) & 0x1) == 0)
9707                                             {
9708                                               if (((word >> 4) & 0x1) == 0)
9709                                                 {
9710                                                   /* 33222222222211111111110000000000
9711                                                      10987654321098765432109876543210
9712                                                      001001x0xx0xxxxx110xxxxxxxx0xxxx
9713                                                      cmphs.  */
9714                                                   return 1346;
9715                                                 }
9716                                               else
9717                                                 {
9718                                                   /* 33222222222211111111110000000000
9719                                                      10987654321098765432109876543210
9720                                                      001001x0xx0xxxxx110xxxxxxxx1xxxx
9721                                                      cmphi.  */
9722                                                   return 1343;
9723                                                 }
9724                                             }
9725                                           else
9726                                             {
9727                                               if (((word >> 22) & 0x1) == 0)
9728                                                 {
9729                                                   if (((word >> 23) & 0x1) == 0)
9730                                                     {
9731                                                       /* 33222222222211111111110000000000
9732                                                          10987654321098765432109876543210
9733                                                          101001x0000xxxxx110xxxxxxxxxxxxx
9734                                                          ldnt1b.  */
9735                                                       return 1732;
9736                                                     }
9737                                                   else
9738                                                     {
9739                                                       /* 33222222222211111111110000000000
9740                                                          10987654321098765432109876543210
9741                                                          101001x0100xxxxx110xxxxxxxxxxxxx
9742                                                          ldnt1h.  */
9743                                                       return 1736;
9744                                                     }
9745                                                 }
9746                                               else
9747                                                 {
9748                                                   if (((word >> 23) & 0x1) == 0)
9749                                                     {
9750                                                       /* 33222222222211111111110000000000
9751                                                          10987654321098765432109876543210
9752                                                          101001x0010xxxxx110xxxxxxxxxxxxx
9753                                                          ld3b.  */
9754                                                       return 1624;
9755                                                     }
9756                                                   else
9757                                                     {
9758                                                       /* 33222222222211111111110000000000
9759                                                          10987654321098765432109876543210
9760                                                          101001x0110xxxxx110xxxxxxxxxxxxx
9761                                                          ld3h.  */
9762                                                       return 1628;
9763                                                     }
9764                                                 }
9765                                             }
9766                                         }
9767                                     }
9768                                   else
9769                                     {
9770                                       if (((word >> 31) & 0x1) == 0)
9771                                         {
9772                                           if (((word >> 17) & 0x1) == 0)
9773                                             {
9774                                               if (((word >> 18) & 0x1) == 0)
9775                                                 {
9776                                                   if (((word >> 20) & 0x1) == 0)
9777                                                     {
9778                                                       /* 33222222222211111111110000000000
9779                                                          10987654321098765432109876543210
9780                                                          011001x0xx00x00x1x0xxxxxxxxxxxxx
9781                                                          fcadd.  */
9782                                                       return 1401;
9783                                                     }
9784                                                   else
9785                                                     {
9786                                                       /* 33222222222211111111110000000000
9787                                                          10987654321098765432109876543210
9788                                                          011001x0xx01x00x1x0xxxxxxxxxxxxx
9789                                                          faddp.  */
9790                                                       return 2082;
9791                                                     }
9792                                                 }
9793                                               else
9794                                                 {
9795                                                   if (((word >> 16) & 0x1) == 0)
9796                                                     {
9797                                                       /* 33222222222211111111110000000000
9798                                                          10987654321098765432109876543210
9799                                                          011001x0xx0xx1001x0xxxxxxxxxxxxx
9800                                                          fmaxnmp.  */
9801                                                       return 2090;
9802                                                     }
9803                                                   else
9804                                                     {
9805                                                       /* 33222222222211111111110000000000
9806                                                          10987654321098765432109876543210
9807                                                          011001x0xx0xx1011x0xxxxxxxxxxxxx
9808                                                          fminnmp.  */
9809                                                       return 2092;
9810                                                     }
9811                                                 }
9812                                             }
9813                                           else
9814                                             {
9815                                               if (((word >> 16) & 0x1) == 0)
9816                                                 {
9817                                                   /* 33222222222211111111110000000000
9818                                                      10987654321098765432109876543210
9819                                                      011001x0xx0xxx101x0xxxxxxxxxxxxx
9820                                                      fmaxp.  */
9821                                                   return 2091;
9822                                                 }
9823                                               else
9824                                                 {
9825                                                   /* 33222222222211111111110000000000
9826                                                      10987654321098765432109876543210
9827                                                      011001x0xx0xxx111x0xxxxxxxxxxxxx
9828                                                      fminp.  */
9829                                                   return 2093;
9830                                                 }
9831                                             }
9832                                         }
9833                                       else
9834                                         {
9835                                           if (((word >> 22) & 0x1) == 0)
9836                                             {
9837                                               if (((word >> 23) & 0x1) == 0)
9838                                                 {
9839                                                   /* 33222222222211111111110000000000
9840                                                      10987654321098765432109876543210
9841                                                      111001x0000xxxxx1x0xxxxxxxxxxxxx
9842                                                      st1b.  */
9843                                                   return 1880;
9844                                                 }
9845                                               else
9846                                                 {
9847                                                   /* 33222222222211111111110000000000
9848                                                      10987654321098765432109876543210
9849                                                      111001x0100xxxxx1x0xxxxxxxxxxxxx
9850                                                      st1h.  */
9851                                                   return 1899;
9852                                                 }
9853                                             }
9854                                           else
9855                                             {
9856                                               if (((word >> 23) & 0x1) == 0)
9857                                                 {
9858                                                   /* 33222222222211111111110000000000
9859                                                      10987654321098765432109876543210
9860                                                      111001x0010xxxxx1x0xxxxxxxxxxxxx
9861                                                      st1b.  */
9862                                                   return 1884;
9863                                                 }
9864                                               else
9865                                                 {
9866                                                   /* 33222222222211111111110000000000
9867                                                      10987654321098765432109876543210
9868                                                      111001x0110xxxxx1x0xxxxxxxxxxxxx
9869                                                      st1h.  */
9870                                                   return 1905;
9871                                                 }
9872                                             }
9873                                         }
9874                                     }
9875                                 }
9876                               else
9877                                 {
9878                                   if (((word >> 14) & 0x1) == 0)
9879                                     {
9880                                       if (((word >> 30) & 0x1) == 0)
9881                                         {
9882                                           if (((word >> 31) & 0x1) == 0)
9883                                             {
9884                                               if (((word >> 4) & 0x1) == 0)
9885                                                 {
9886                                                   /* 33222222222211111111110000000000
9887                                                      10987654321098765432109876543210
9888                                                      001001x0xx0xxxxx101xxxxxxxx0xxxx
9889                                                      cmpeq.  */
9890                                                   return 1334;
9891                                                 }
9892                                               else
9893                                                 {
9894                                                   /* 33222222222211111111110000000000
9895                                                      10987654321098765432109876543210
9896                                                      001001x0xx0xxxxx101xxxxxxxx1xxxx
9897                                                      cmpne.  */
9898                                                   return 1357;
9899                                                 }
9900                                             }
9901                                           else
9902                                             {
9903                                               if (((word >> 20) & 0x1) == 0)
9904                                                 {
9905                                                   if (((word >> 22) & 0x1) == 0)
9906                                                     {
9907                                                       if (((word >> 23) & 0x1) == 0)
9908                                                         {
9909                                                           /* 33222222222211111111110000000000
9910                                                              10987654321098765432109876543210
9911                                                              101001x00000xxxx101xxxxxxxxxxxxx
9912                                                              ld1b.  */
9913                                                           return 1524;
9914                                                         }
9915                                                       else
9916                                                         {
9917                                                           /* 33222222222211111111110000000000
9918                                                              10987654321098765432109876543210
9919                                                              101001x01000xxxx101xxxxxxxxxxxxx
9920                                                              ld1sw.  */
9921                                                           return 1602;
9922                                                         }
9923                                                     }
9924                                                   else
9925                                                     {
9926                                                       if (((word >> 23) & 0x1) == 0)
9927                                                         {
9928                                                           /* 33222222222211111111110000000000
9929                                                              10987654321098765432109876543210
9930                                                              101001x00100xxxx101xxxxxxxxxxxxx
9931                                                              ld1b.  */
9932                                                           return 1526;
9933                                                         }
9934                                                       else
9935                                                         {
9936                                                           /* 33222222222211111111110000000000
9937                                                              10987654321098765432109876543210
9938                                                              101001x01100xxxx101xxxxxxxxxxxxx
9939                                                              ld1h.  */
9940                                                           return 1547;
9941                                                         }
9942                                                     }
9943                                                 }
9944                                               else
9945                                                 {
9946                                                   if (((word >> 22) & 0x1) == 0)
9947                                                     {
9948                                                       if (((word >> 23) & 0x1) == 0)
9949                                                         {
9950                                                           /* 33222222222211111111110000000000
9951                                                              10987654321098765432109876543210
9952                                                              101001x00001xxxx101xxxxxxxxxxxxx
9953                                                              ldnf1b.  */
9954                                                           return 1716;
9955                                                         }
9956                                                       else
9957                                                         {
9958                                                           /* 33222222222211111111110000000000
9959                                                              10987654321098765432109876543210
9960                                                              101001x01001xxxx101xxxxxxxxxxxxx
9961                                                              ldnf1sw.  */
9962                                                           return 1729;
9963                                                         }
9964                                                     }
9965                                                   else
9966                                                     {
9967                                                       if (((word >> 23) & 0x1) == 0)
9968                                                         {
9969                                                           /* 33222222222211111111110000000000
9970                                                              10987654321098765432109876543210
9971                                                              101001x00101xxxx101xxxxxxxxxxxxx
9972                                                              ldnf1b.  */
9973                                                           return 1718;
9974                                                         }
9975                                                       else
9976                                                         {
9977                                                           /* 33222222222211111111110000000000
9978                                                              10987654321098765432109876543210
9979                                                              101001x01101xxxx101xxxxxxxxxxxxx
9980                                                              ldnf1h.  */
9981                                                           return 1722;
9982                                                         }
9983                                                     }
9984                                                 }
9985                                             }
9986                                         }
9987                                       else
9988                                         {
9989                                           if (((word >> 22) & 0x1) == 0)
9990                                             {
9991                                               if (((word >> 23) & 0x1) == 0)
9992                                                 {
9993                                                   if (((word >> 31) & 0x1) == 0)
9994                                                     {
9995                                                       /* 33222222222211111111110000000000
9996                                                          10987654321098765432109876543210
9997                                                          011001x0000xxxxx101xxxxxxxxxxxxx
9998                                                          fcvtxnt.  */
9999                                                       return 2088;
10000                                                     }
10001                                                   else
10002                                                     {
10003                                                       /* 33222222222211111111110000000000
10004                                                          10987654321098765432109876543210
10005                                                          111001x0000xxxxx101xxxxxxxxxxxxx
10006                                                          st1b.  */
10007                                                       return 1881;
10008                                                     }
10009                                                 }
10010                                               else
10011                                                 {
10012                                                   if (((word >> 31) & 0x1) == 0)
10013                                                     {
10014                                                       if (((word >> 16) & 0x1) == 0)
10015                                                         {
10016                                                           if (((word >> 17) & 0x1) == 0)
10017                                                             {
10018                                                               /* 33222222222211111111110000000000
10019                                                                  10987654321098765432109876543210
10020                                                                  011001x0100xxx00101xxxxxxxxxxxxx
10021                                                                  fcvtnt.  */
10022                                                               return 2085;
10023                                                             }
10024                                                           else
10025                                                             {
10026                                                               /* 33222222222211111111110000000000
10027                                                                  10987654321098765432109876543210
10028                                                                  011001x0100xxx10101xxxxxxxxxxxxx
10029                                                                  bfcvtnt.  */
10030                                                               return 2500;
10031                                                             }
10032                                                         }
10033                                                       else
10034                                                         {
10035                                                           /* 33222222222211111111110000000000
10036                                                              10987654321098765432109876543210
10037                                                              011001x0100xxxx1101xxxxxxxxxxxxx
10038                                                              fcvtlt.  */
10039                                                           return 2083;
10040                                                         }
10041                                                     }
10042                                                   else
10043                                                     {
10044                                                       /* 33222222222211111111110000000000
10045                                                          10987654321098765432109876543210
10046                                                          111001x0100xxxxx101xxxxxxxxxxxxx
10047                                                          st1h.  */
10048                                                       return 1900;
10049                                                     }
10050                                                 }
10051                                             }
10052                                           else
10053                                             {
10054                                               if (((word >> 23) & 0x1) == 0)
10055                                                 {
10056                                                   /* 33222222222211111111110000000000
10057                                                      10987654321098765432109876543210
10058                                                      x11001x0010xxxxx101xxxxxxxxxxxxx
10059                                                      st1b.  */
10060                                                   return 1888;
10061                                                 }
10062                                               else
10063                                                 {
10064                                                   if (((word >> 31) & 0x1) == 0)
10065                                                     {
10066                                                       if (((word >> 16) & 0x1) == 0)
10067                                                         {
10068                                                           /* 33222222222211111111110000000000
10069                                                              10987654321098765432109876543210
10070                                                              011001x0110xxxx0101xxxxxxxxxxxxx
10071                                                              fcvtnt.  */
10072                                                           return 2086;
10073                                                         }
10074                                                       else
10075                                                         {
10076                                                           /* 33222222222211111111110000000000
10077                                                              10987654321098765432109876543210
10078                                                              011001x0110xxxx1101xxxxxxxxxxxxx
10079                                                              fcvtlt.  */
10080                                                           return 2084;
10081                                                         }
10082                                                     }
10083                                                   else
10084                                                     {
10085                                                       /* 33222222222211111111110000000000
10086                                                          10987654321098765432109876543210
10087                                                          111001x0110xxxxx101xxxxxxxxxxxxx
10088                                                          st1h.  */
10089                                                       return 1909;
10090                                                     }
10091                                                 }
10092                                             }
10093                                         }
10094                                     }
10095                                   else
10096                                     {
10097                                       if (((word >> 30) & 0x1) == 0)
10098                                         {
10099                                           if (((word >> 31) & 0x1) == 0)
10100                                             {
10101                                               if (((word >> 4) & 0x1) == 0)
10102                                                 {
10103                                                   /* 33222222222211111111110000000000
10104                                                      10987654321098765432109876543210
10105                                                      001001x0xx0xxxxx111xxxxxxxx0xxxx
10106                                                      cmplo.  */
10107                                                   return 1350;
10108                                                 }
10109                                               else
10110                                                 {
10111                                                   /* 33222222222211111111110000000000
10112                                                      10987654321098765432109876543210
10113                                                      001001x0xx0xxxxx111xxxxxxxx1xxxx
10114                                                      cmpls.  */
10115                                                   return 1352;
10116                                                 }
10117                                             }
10118                                           else
10119                                             {
10120                                               if (((word >> 22) & 0x1) == 0)
10121                                                 {
10122                                                   if (((word >> 23) & 0x1) == 0)
10123                                                     {
10124                                                       /* 33222222222211111111110000000000
10125                                                          10987654321098765432109876543210
10126                                                          101001x0000xxxxx111xxxxxxxxxxxxx
10127                                                          ldnt1b.  */
10128                                                       return 1733;
10129                                                     }
10130                                                   else
10131                                                     {
10132                                                       /* 33222222222211111111110000000000
10133                                                          10987654321098765432109876543210
10134                                                          101001x0100xxxxx111xxxxxxxxxxxxx
10135                                                          ldnt1h.  */
10136                                                       return 1737;
10137                                                     }
10138                                                 }
10139                                               else
10140                                                 {
10141                                                   if (((word >> 23) & 0x1) == 0)
10142                                                     {
10143                                                       /* 33222222222211111111110000000000
10144                                                          10987654321098765432109876543210
10145                                                          101001x0010xxxxx111xxxxxxxxxxxxx
10146                                                          ld3b.  */
10147                                                       return 1625;
10148                                                     }
10149                                                   else
10150                                                     {
10151                                                       /* 33222222222211111111110000000000
10152                                                          10987654321098765432109876543210
10153                                                          101001x0110xxxxx111xxxxxxxxxxxxx
10154                                                          ld3h.  */
10155                                                       return 1629;
10156                                                     }
10157                                                 }
10158                                             }
10159                                         }
10160                                       else
10161                                         {
10162                                           if (((word >> 20) & 0x1) == 0)
10163                                             {
10164                                               if (((word >> 22) & 0x1) == 0)
10165                                                 {
10166                                                   /* 33222222222211111111110000000000
10167                                                      10987654321098765432109876543210
10168                                                      x11001x0x000xxxx111xxxxxxxxxxxxx
10169                                                      st1b.  */
10170                                                   return 1886;
10171                                                 }
10172                                               else
10173                                                 {
10174                                                   if (((word >> 23) & 0x1) == 0)
10175                                                     {
10176                                                       /* 33222222222211111111110000000000
10177                                                          10987654321098765432109876543210
10178                                                          x11001x00100xxxx111xxxxxxxxxxxxx
10179                                                          st1b.  */
10180                                                       return 1889;
10181                                                     }
10182                                                   else
10183                                                     {
10184                                                       /* 33222222222211111111110000000000
10185                                                          10987654321098765432109876543210
10186                                                          x11001x01100xxxx111xxxxxxxxxxxxx
10187                                                          st1h.  */
10188                                                       return 1910;
10189                                                     }
10190                                                 }
10191                                             }
10192                                           else
10193                                             {
10194                                               if (((word >> 22) & 0x1) == 0)
10195                                                 {
10196                                                   if (((word >> 23) & 0x1) == 0)
10197                                                     {
10198                                                       /* 33222222222211111111110000000000
10199                                                          10987654321098765432109876543210
10200                                                          x11001x00001xxxx111xxxxxxxxxxxxx
10201                                                          stnt1b.  */
10202                                                       return 1950;
10203                                                     }
10204                                                   else
10205                                                     {
10206                                                       /* 33222222222211111111110000000000
10207                                                          10987654321098765432109876543210
10208                                                          x11001x01001xxxx111xxxxxxxxxxxxx
10209                                                          stnt1h.  */
10210                                                       return 1954;
10211                                                     }
10212                                                 }
10213                                               else
10214                                                 {
10215                                                   if (((word >> 23) & 0x1) == 0)
10216                                                     {
10217                                                       /* 33222222222211111111110000000000
10218                                                          10987654321098765432109876543210
10219                                                          x11001x00101xxxx111xxxxxxxxxxxxx
10220                                                          st3b.  */
10221                                                       return 1934;
10222                                                     }
10223                                                   else
10224                                                     {
10225                                                       /* 33222222222211111111110000000000
10226                                                          10987654321098765432109876543210
10227                                                          x11001x01101xxxx111xxxxxxxxxxxxx
10228                                                          st3h.  */
10229                                                       return 1938;
10230                                                     }
10231                                                 }
10232                                             }
10233                                         }
10234                                     }
10235                                 }
10236                             }
10237                         }
10238                       else
10239                         {
10240                           if (((word >> 13) & 0x1) == 0)
10241                             {
10242                               if (((word >> 30) & 0x1) == 0)
10243                                 {
10244                                   if (((word >> 31) & 0x1) == 0)
10245                                     {
10246                                       if (((word >> 4) & 0x1) == 0)
10247                                         {
10248                                           /* 33222222222211111111110000000000
10249                                              10987654321098765432109876543210
10250                                              001001x0xx1xxxxxxx0xxxxxxxx0xxxx
10251                                              cmphs.  */
10252                                           return 1347;
10253                                         }
10254                                       else
10255                                         {
10256                                           /* 33222222222211111111110000000000
10257                                              10987654321098765432109876543210
10258                                              001001x0xx1xxxxxxx0xxxxxxxx1xxxx
10259                                              cmphi.  */
10260                                           return 1344;
10261                                         }
10262                                     }
10263                                   else
10264                                     {
10265                                       if (((word >> 14) & 0x1) == 0)
10266                                         {
10267                                           if (((word >> 23) & 0x1) == 0)
10268                                             {
10269                                               /* 33222222222211111111110000000000
10270                                                  10987654321098765432109876543210
10271                                                  101001x00x1xxxxxx00xxxxxxxxxxxxx
10272                                                  ld1rob.  */
10273                                               return 2476;
10274                                             }
10275                                           else
10276                                             {
10277                                               /* 33222222222211111111110000000000
10278                                                  10987654321098765432109876543210
10279                                                  101001x01x1xxxxxx00xxxxxxxxxxxxx
10280                                                  ld1roh.  */
10281                                               return 2477;
10282                                             }
10283                                         }
10284                                       else
10285                                         {
10286                                           if (((word >> 15) & 0x1) == 0)
10287                                             {
10288                                               if (((word >> 22) & 0x1) == 0)
10289                                                 {
10290                                                   if (((word >> 23) & 0x1) == 0)
10291                                                     {
10292                                                       /* 33222222222211111111110000000000
10293                                                          10987654321098765432109876543210
10294                                                          101001x0001xxxxx010xxxxxxxxxxxxx
10295                                                          ld1b.  */
10296                                                       return 1518;
10297                                                     }
10298                                                   else
10299                                                     {
10300                                                       /* 33222222222211111111110000000000
10301                                                          10987654321098765432109876543210
10302                                                          101001x0101xxxxx010xxxxxxxxxxxxx
10303                                                          ld1h.  */
10304                                                       return 1538;
10305                                                     }
10306                                                 }
10307                                               else
10308                                                 {
10309                                                   if (((word >> 23) & 0x1) == 0)
10310                                                     {
10311                                                       /* 33222222222211111111110000000000
10312                                                          10987654321098765432109876543210
10313                                                          101001x0011xxxxx010xxxxxxxxxxxxx
10314                                                          ld1b.  */
10315                                                       return 1520;
10316                                                     }
10317                                                   else
10318                                                     {
10319                                                       /* 33222222222211111111110000000000
10320                                                          10987654321098765432109876543210
10321                                                          101001x0111xxxxx010xxxxxxxxxxxxx
10322                                                          ld1h.  */
10323                                                       return 1540;
10324                                                     }
10325                                                 }
10326                                             }
10327                                           else
10328                                             {
10329                                               if (((word >> 22) & 0x1) == 0)
10330                                                 {
10331                                                   if (((word >> 23) & 0x1) == 0)
10332                                                     {
10333                                                       /* 33222222222211111111110000000000
10334                                                          10987654321098765432109876543210
10335                                                          101001x0001xxxxx110xxxxxxxxxxxxx
10336                                                          ld2b.  */
10337                                                       return 1616;
10338                                                     }
10339                                                   else
10340                                                     {
10341                                                       /* 33222222222211111111110000000000
10342                                                          10987654321098765432109876543210
10343                                                          101001x0101xxxxx110xxxxxxxxxxxxx
10344                                                          ld2h.  */
10345                                                       return 1620;
10346                                                     }
10347                                                 }
10348                                               else
10349                                                 {
10350                                                   if (((word >> 23) & 0x1) == 0)
10351                                                     {
10352                                                       /* 33222222222211111111110000000000
10353                                                          10987654321098765432109876543210
10354                                                          101001x0011xxxxx110xxxxxxxxxxxxx
10355                                                          ld4b.  */
10356                                                       return 1632;
10357                                                     }
10358                                                   else
10359                                                     {
10360                                                       /* 33222222222211111111110000000000
10361                                                          10987654321098765432109876543210
10362                                                          101001x0111xxxxx110xxxxxxxxxxxxx
10363                                                          ld4h.  */
10364                                                       return 1636;
10365                                                     }
10366                                                 }
10367                                             }
10368                                         }
10369                                     }
10370                                 }
10371                               else
10372                                 {
10373                                   if (((word >> 15) & 0x1) == 0)
10374                                     {
10375                                       if (((word >> 14) & 0x1) == 0)
10376                                         {
10377                                           if (((word >> 12) & 0x1) == 0)
10378                                             {
10379                                               if (((word >> 10) & 0x1) == 0)
10380                                                 {
10381                                                   if (((word >> 23) & 0x1) == 0)
10382                                                     {
10383                                                       /* 33222222222211111111110000000000
10384                                                          10987654321098765432109876543210
10385                                                          x11001x00x1xxxxx0000x0xxxxxxxxxx
10386                                                          fmla.  */
10387                                                       return 1455;
10388                                                     }
10389                                                   else
10390                                                     {
10391                                                       if (((word >> 22) & 0x1) == 0)
10392                                                         {
10393                                                           /* 33222222222211111111110000000000
10394                                                              10987654321098765432109876543210
10395                                                              x11001x0101xxxxx0000x0xxxxxxxxxx
10396                                                              fmla.  */
10397                                                           return 1456;
10398                                                         }
10399                                                       else
10400                                                         {
10401                                                           /* 33222222222211111111110000000000
10402                                                              10987654321098765432109876543210
10403                                                              x11001x0111xxxxx0000x0xxxxxxxxxx
10404                                                              fmla.  */
10405                                                           return 1457;
10406                                                         }
10407                                                     }
10408                                                 }
10409                                               else
10410                                                 {
10411                                                   if (((word >> 23) & 0x1) == 0)
10412                                                     {
10413                                                       /* 33222222222211111111110000000000
10414                                                          10987654321098765432109876543210
10415                                                          x11001x00x1xxxxx0000x1xxxxxxxxxx
10416                                                          fmls.  */
10417                                                       return 1459;
10418                                                     }
10419                                                   else
10420                                                     {
10421                                                       if (((word >> 22) & 0x1) == 0)
10422                                                         {
10423                                                           /* 33222222222211111111110000000000
10424                                                              10987654321098765432109876543210
10425                                                              x11001x0101xxxxx0000x1xxxxxxxxxx
10426                                                              fmls.  */
10427                                                           return 1460;
10428                                                         }
10429                                                       else
10430                                                         {
10431                                                           /* 33222222222211111111110000000000
10432                                                              10987654321098765432109876543210
10433                                                              x11001x0111xxxxx0000x1xxxxxxxxxx
10434                                                              fmls.  */
10435                                                           return 1461;
10436                                                         }
10437                                                     }
10438                                                 }
10439                                             }
10440                                           else
10441                                             {
10442                                               if (((word >> 22) & 0x1) == 0)
10443                                                 {
10444                                                   /* 33222222222211111111110000000000
10445                                                      10987654321098765432109876543210
10446                                                      x11001x0x01xxxxx0001xxxxxxxxxxxx
10447                                                      fcmla.  */
10448                                                   return 1403;
10449                                                 }
10450                                               else
10451                                                 {
10452                                                   /* 33222222222211111111110000000000
10453                                                      10987654321098765432109876543210
10454                                                      x11001x0x11xxxxx0001xxxxxxxxxxxx
10455                                                      fcmla.  */
10456                                                   return 1404;
10457                                                 }
10458                                             }
10459                                         }
10460                                       else
10461                                         {
10462                                           if (((word >> 22) & 0x1) == 0)
10463                                             {
10464                                               if (((word >> 23) & 0x1) == 0)
10465                                                 {
10466                                                   /* 33222222222211111111110000000000
10467                                                      10987654321098765432109876543210
10468                                                      x11001x0001xxxxx010xxxxxxxxxxxxx
10469                                                      st1b.  */
10470                                                   return 1882;
10471                                                 }
10472                                               else
10473                                                 {
10474                                                   if (((word >> 31) & 0x1) == 0)
10475                                                     {
10476                                                       if (((word >> 10) & 0x1) == 0)
10477                                                         {
10478                                                           /* 33222222222211111111110000000000
10479                                                              10987654321098765432109876543210
10480                                                              011001x0101xxxxx010xx0xxxxxxxxxx
10481                                                              fmlalb.  */
10482                                                           return 2094;
10483                                                         }
10484                                                       else
10485                                                         {
10486                                                           /* 33222222222211111111110000000000
10487                                                              10987654321098765432109876543210
10488                                                              011001x0101xxxxx010xx1xxxxxxxxxx
10489                                                              fmlalt.  */
10490                                                           return 2096;
10491                                                         }
10492                                                     }
10493                                                   else
10494                                                     {
10495                                                       /* 33222222222211111111110000000000
10496                                                          10987654321098765432109876543210
10497                                                          111001x0101xxxxx010xxxxxxxxxxxxx
10498                                                          st1h.  */
10499                                                       return 1901;
10500                                                     }
10501                                                 }
10502                                             }
10503                                           else
10504                                             {
10505                                               if (((word >> 23) & 0x1) == 0)
10506                                                 {
10507                                                   if (((word >> 31) & 0x1) == 0)
10508                                                     {
10509                                                       /* 33222222222211111111110000000000
10510                                                          10987654321098765432109876543210
10511                                                          011001x0011xxxxx010xxxxxxxxxxxxx
10512                                                          bfdot.  */
10513                                                       return 2497;
10514                                                     }
10515                                                   else
10516                                                     {
10517                                                       /* 33222222222211111111110000000000
10518                                                          10987654321098765432109876543210
10519                                                          111001x0011xxxxx010xxxxxxxxxxxxx
10520                                                          st1b.  */
10521                                                       return 1885;
10522                                                     }
10523                                                 }
10524                                               else
10525                                                 {
10526                                                   if (((word >> 31) & 0x1) == 0)
10527                                                     {
10528                                                       if (((word >> 10) & 0x1) == 0)
10529                                                         {
10530                                                           /* 33222222222211111111110000000000
10531                                                              10987654321098765432109876543210
10532                                                              011001x0111xxxxx010xx0xxxxxxxxxx
10533                                                              bfmlalb.  */
10534                                                           return 2504;
10535                                                         }
10536                                                       else
10537                                                         {
10538                                                           /* 33222222222211111111110000000000
10539                                                              10987654321098765432109876543210
10540                                                              011001x0111xxxxx010xx1xxxxxxxxxx
10541                                                              bfmlalt.  */
10542                                                           return 2503;
10543                                                         }
10544                                                     }
10545                                                   else
10546                                                     {
10547                                                       /* 33222222222211111111110000000000
10548                                                          10987654321098765432109876543210
10549                                                          111001x0111xxxxx010xxxxxxxxxxxxx
10550                                                          st1h.  */
10551                                                       return 1906;
10552                                                     }
10553                                                 }
10554                                             }
10555                                         }
10556                                     }
10557                                   else
10558                                     {
10559                                       if (((word >> 22) & 0x1) == 0)
10560                                         {
10561                                           if (((word >> 31) & 0x1) == 0)
10562                                             {
10563                                               if (((word >> 10) & 0x1) == 0)
10564                                                 {
10565                                                   /* 33222222222211111111110000000000
10566                                                      10987654321098765432109876543210
10567                                                      011001x0x01xxxxx1x0xx0xxxxxxxxxx
10568                                                      fmlalb.  */
10569                                                   return 2095;
10570                                                 }
10571                                               else
10572                                                 {
10573                                                   /* 33222222222211111111110000000000
10574                                                      10987654321098765432109876543210
10575                                                      011001x0x01xxxxx1x0xx1xxxxxxxxxx
10576                                                      fmlalt.  */
10577                                                   return 2097;
10578                                                 }
10579                                             }
10580                                           else
10581                                             {
10582                                               /* 33222222222211111111110000000000
10583                                                  10987654321098765432109876543210
10584                                                  111001x0x01xxxxx1x0xxxxxxxxxxxxx
10585                                                  st1h.  */
10586                                               return 1902;
10587                                             }
10588                                         }
10589                                       else
10590                                         {
10591                                           if (((word >> 23) & 0x1) == 0)
10592                                             {
10593                                               /* 33222222222211111111110000000000
10594                                                  10987654321098765432109876543210
10595                                                  x11001x0011xxxxx1x0xxxxxxxxxxxxx
10596                                                  bfdot.  */
10597                                               return 2496;
10598                                             }
10599                                           else
10600                                             {
10601                                               if (((word >> 31) & 0x1) == 0)
10602                                                 {
10603                                                   if (((word >> 10) & 0x1) == 0)
10604                                                     {
10605                                                       /* 33222222222211111111110000000000
10606                                                          10987654321098765432109876543210
10607                                                          011001x0111xxxxx1x0xx0xxxxxxxxxx
10608                                                          bfmlalb.  */
10609                                                       return 2502;
10610                                                     }
10611                                                   else
10612                                                     {
10613                                                       /* 33222222222211111111110000000000
10614                                                          10987654321098765432109876543210
10615                                                          011001x0111xxxxx1x0xx1xxxxxxxxxx
10616                                                          bfmlalt.  */
10617                                                       return 2501;
10618                                                     }
10619                                                 }
10620                                               else
10621                                                 {
10622                                                   /* 33222222222211111111110000000000
10623                                                      10987654321098765432109876543210
10624                                                      111001x0111xxxxx1x0xxxxxxxxxxxxx
10625                                                      st1h.  */
10626                                                   return 1907;
10627                                                 }
10628                                             }
10629                                         }
10630                                     }
10631                                 }
10632                             }
10633                           else
10634                             {
10635                               if (((word >> 30) & 0x1) == 0)
10636                                 {
10637                                   if (((word >> 31) & 0x1) == 0)
10638                                     {
10639                                       if (((word >> 4) & 0x1) == 0)
10640                                         {
10641                                           /* 33222222222211111111110000000000
10642                                              10987654321098765432109876543210
10643                                              001001x0xx1xxxxxxx1xxxxxxxx0xxxx
10644                                              cmplo.  */
10645                                           return 1351;
10646                                         }
10647                                       else
10648                                         {
10649                                           /* 33222222222211111111110000000000
10650                                              10987654321098765432109876543210
10651                                              001001x0xx1xxxxxxx1xxxxxxxx1xxxx
10652                                              cmpls.  */
10653                                           return 1353;
10654                                         }
10655                                     }
10656                                   else
10657                                     {
10658                                       if (((word >> 14) & 0x1) == 0)
10659                                         {
10660                                           if (((word >> 15) & 0x1) == 0)
10661                                             {
10662                                               if (((word >> 23) & 0x1) == 0)
10663                                                 {
10664                                                   /* 33222222222211111111110000000000
10665                                                      10987654321098765432109876543210
10666                                                      101001x00x1xxxxx001xxxxxxxxxxxxx
10667                                                      ld1rob.  */
10668                                                   return 2480;
10669                                                 }
10670                                               else
10671                                                 {
10672                                                   /* 33222222222211111111110000000000
10673                                                      10987654321098765432109876543210
10674                                                      101001x01x1xxxxx001xxxxxxxxxxxxx
10675                                                      ld1roh.  */
10676                                                   return 2481;
10677                                                 }
10678                                             }
10679                                           else
10680                                             {
10681                                               if (((word >> 20) & 0x1) == 0)
10682                                                 {
10683                                                   if (((word >> 22) & 0x1) == 0)
10684                                                     {
10685                                                       if (((word >> 23) & 0x1) == 0)
10686                                                         {
10687                                                           /* 33222222222211111111110000000000
10688                                                              10987654321098765432109876543210
10689                                                              101001x00010xxxx101xxxxxxxxxxxxx
10690                                                              ld1b.  */
10691                                                           return 1525;
10692                                                         }
10693                                                       else
10694                                                         {
10695                                                           /* 33222222222211111111110000000000
10696                                                              10987654321098765432109876543210
10697                                                              101001x01010xxxx101xxxxxxxxxxxxx
10698                                                              ld1h.  */
10699                                                           return 1546;
10700                                                         }
10701                                                     }
10702                                                   else
10703                                                     {
10704                                                       if (((word >> 23) & 0x1) == 0)
10705                                                         {
10706                                                           /* 33222222222211111111110000000000
10707                                                              10987654321098765432109876543210
10708                                                              101001x00110xxxx101xxxxxxxxxxxxx
10709                                                              ld1b.  */
10710                                                           return 1527;
10711                                                         }
10712                                                       else
10713                                                         {
10714                                                           /* 33222222222211111111110000000000
10715                                                              10987654321098765432109876543210
10716                                                              101001x01110xxxx101xxxxxxxxxxxxx
10717                                                              ld1h.  */
10718                                                           return 1548;
10719                                                         }
10720                                                     }
10721                                                 }
10722                                               else
10723                                                 {
10724                                                   if (((word >> 22) & 0x1) == 0)
10725                                                     {
10726                                                       if (((word >> 23) & 0x1) == 0)
10727                                                         {
10728                                                           /* 33222222222211111111110000000000
10729                                                              10987654321098765432109876543210
10730                                                              101001x00011xxxx101xxxxxxxxxxxxx
10731                                                              ldnf1b.  */
10732                                                           return 1717;
10733                                                         }
10734                                                       else
10735                                                         {
10736                                                           /* 33222222222211111111110000000000
10737                                                              10987654321098765432109876543210
10738                                                              101001x01011xxxx101xxxxxxxxxxxxx
10739                                                              ldnf1h.  */
10740                                                           return 1721;
10741                                                         }
10742                                                     }
10743                                                   else
10744                                                     {
10745                                                       if (((word >> 23) & 0x1) == 0)
10746                                                         {
10747                                                           /* 33222222222211111111110000000000
10748                                                              10987654321098765432109876543210
10749                                                              101001x00111xxxx101xxxxxxxxxxxxx
10750                                                              ldnf1b.  */
10751                                                           return 1719;
10752                                                         }
10753                                                       else
10754                                                         {
10755                                                           /* 33222222222211111111110000000000
10756                                                              10987654321098765432109876543210
10757                                                              101001x01111xxxx101xxxxxxxxxxxxx
10758                                                              ldnf1h.  */
10759                                                           return 1723;
10760                                                         }
10761                                                     }
10762                                                 }
10763                                             }
10764                                         }
10765                                       else
10766                                         {
10767                                           if (((word >> 15) & 0x1) == 0)
10768                                             {
10769                                               if (((word >> 22) & 0x1) == 0)
10770                                                 {
10771                                                   if (((word >> 23) & 0x1) == 0)
10772                                                     {
10773                                                       /* 33222222222211111111110000000000
10774                                                          10987654321098765432109876543210
10775                                                          101001x0001xxxxx011xxxxxxxxxxxxx
10776                                                          ldff1b.  */
10777                                                       return 1643;
10778                                                     }
10779                                                   else
10780                                                     {
10781                                                       /* 33222222222211111111110000000000
10782                                                          10987654321098765432109876543210
10783                                                          101001x0101xxxxx011xxxxxxxxxxxxx
10784                                                          ldff1h.  */
10785                                                       return 1662;
10786                                                     }
10787                                                 }
10788                                               else
10789                                                 {
10790                                                   if (((word >> 23) & 0x1) == 0)
10791                                                     {
10792                                                       /* 33222222222211111111110000000000
10793                                                          10987654321098765432109876543210
10794                                                          101001x0011xxxxx011xxxxxxxxxxxxx
10795                                                          ldff1b.  */
10796                                                       return 1647;
10797                                                     }
10798                                                   else
10799                                                     {
10800                                                       /* 33222222222211111111110000000000
10801                                                          10987654321098765432109876543210
10802                                                          101001x0111xxxxx011xxxxxxxxxxxxx
10803                                                          ldff1h.  */
10804                                                       return 1666;
10805                                                     }
10806                                                 }
10807                                             }
10808                                           else
10809                                             {
10810                                               if (((word >> 22) & 0x1) == 0)
10811                                                 {
10812                                                   if (((word >> 23) & 0x1) == 0)
10813                                                     {
10814                                                       /* 33222222222211111111110000000000
10815                                                          10987654321098765432109876543210
10816                                                          101001x0001xxxxx111xxxxxxxxxxxxx
10817                                                          ld2b.  */
10818                                                       return 1617;
10819                                                     }
10820                                                   else
10821                                                     {
10822                                                       /* 33222222222211111111110000000000
10823                                                          10987654321098765432109876543210
10824                                                          101001x0101xxxxx111xxxxxxxxxxxxx
10825                                                          ld2h.  */
10826                                                       return 1621;
10827                                                     }
10828                                                 }
10829                                               else
10830                                                 {
10831                                                   if (((word >> 23) & 0x1) == 0)
10832                                                     {
10833                                                       /* 33222222222211111111110000000000
10834                                                          10987654321098765432109876543210
10835                                                          101001x0011xxxxx111xxxxxxxxxxxxx
10836                                                          ld4b.  */
10837                                                       return 1633;
10838                                                     }
10839                                                   else
10840                                                     {
10841                                                       /* 33222222222211111111110000000000
10842                                                          10987654321098765432109876543210
10843                                                          101001x0111xxxxx111xxxxxxxxxxxxx
10844                                                          ld4h.  */
10845                                                       return 1637;
10846                                                     }
10847                                                 }
10848                                             }
10849                                         }
10850                                     }
10851                                 }
10852                               else
10853                                 {
10854                                   if (((word >> 14) & 0x1) == 0)
10855                                     {
10856                                       if (((word >> 15) & 0x1) == 0)
10857                                         {
10858                                           if (((word >> 23) & 0x1) == 0)
10859                                             {
10860                                               /* 33222222222211111111110000000000
10861                                                  10987654321098765432109876543210
10862                                                  x11001x00x1xxxxx001xxxxxxxxxxxxx
10863                                                  fmul.  */
10864                                               return 1466;
10865                                             }
10866                                           else
10867                                             {
10868                                               if (((word >> 22) & 0x1) == 0)
10869                                                 {
10870                                                   /* 33222222222211111111110000000000
10871                                                      10987654321098765432109876543210
10872                                                      x11001x0101xxxxx001xxxxxxxxxxxxx
10873                                                      fmul.  */
10874                                                   return 1467;
10875                                                 }
10876                                               else
10877                                                 {
10878                                                   /* 33222222222211111111110000000000
10879                                                      10987654321098765432109876543210
10880                                                      x11001x0111xxxxx001xxxxxxxxxxxxx
10881                                                      fmul.  */
10882                                                   return 1468;
10883                                                 }
10884                                             }
10885                                         }
10886                                       else
10887                                         {
10888                                           if (((word >> 22) & 0x1) == 0)
10889                                             {
10890                                               if (((word >> 31) & 0x1) == 0)
10891                                                 {
10892                                                   if (((word >> 10) & 0x1) == 0)
10893                                                     {
10894                                                       /* 33222222222211111111110000000000
10895                                                          10987654321098765432109876543210
10896                                                          011001x0x01xxxxx101xx0xxxxxxxxxx
10897                                                          fmlslb.  */
10898                                                       return 2099;
10899                                                     }
10900                                                   else
10901                                                     {
10902                                                       /* 33222222222211111111110000000000
10903                                                          10987654321098765432109876543210
10904                                                          011001x0x01xxxxx101xx1xxxxxxxxxx
10905                                                          fmlslt.  */
10906                                                       return 2101;
10907                                                     }
10908                                                 }
10909                                               else
10910                                                 {
10911                                                   /* 33222222222211111111110000000000
10912                                                      10987654321098765432109876543210
10913                                                      111001x0x01xxxxx101xxxxxxxxxxxxx
10914                                                      st1h.  */
10915                                                   return 1903;
10916                                                 }
10917                                             }
10918                                           else
10919                                             {
10920                                               if (((word >> 23) & 0x1) == 0)
10921                                                 {
10922                                                   /* 33222222222211111111110000000000
10923                                                      10987654321098765432109876543210
10924                                                      x11001x0011xxxxx101xxxxxxxxxxxxx
10925                                                      st1b.  */
10926                                                   return 1890;
10927                                                 }
10928                                               else
10929                                                 {
10930                                                   /* 33222222222211111111110000000000
10931                                                      10987654321098765432109876543210
10932                                                      x11001x0111xxxxx101xxxxxxxxxxxxx
10933                                                      st1h.  */
10934                                                   return 1911;
10935                                                 }
10936                                             }
10937                                         }
10938                                     }
10939                                   else
10940                                     {
10941                                       if (((word >> 15) & 0x1) == 0)
10942                                         {
10943                                           if (((word >> 22) & 0x1) == 0)
10944                                             {
10945                                               if (((word >> 23) & 0x1) == 0)
10946                                                 {
10947                                                   /* 33222222222211111111110000000000
10948                                                      10987654321098765432109876543210
10949                                                      x11001x0001xxxxx011xxxxxxxxxxxxx
10950                                                      st2b.  */
10951                                                   return 1925;
10952                                                 }
10953                                               else
10954                                                 {
10955                                                   if (((word >> 31) & 0x1) == 0)
10956                                                     {
10957                                                       if (((word >> 10) & 0x1) == 0)
10958                                                         {
10959                                                           /* 33222222222211111111110000000000
10960                                                              10987654321098765432109876543210
10961                                                              011001x0101xxxxx011xx0xxxxxxxxxx
10962                                                              fmlslb.  */
10963                                                           return 2098;
10964                                                         }
10965                                                       else
10966                                                         {
10967                                                           /* 33222222222211111111110000000000
10968                                                              10987654321098765432109876543210
10969                                                              011001x0101xxxxx011xx1xxxxxxxxxx
10970                                                              fmlslt.  */
10971                                                           return 2100;
10972                                                         }
10973                                                     }
10974                                                   else
10975                                                     {
10976                                                       /* 33222222222211111111110000000000
10977                                                          10987654321098765432109876543210
10978                                                          111001x0101xxxxx011xxxxxxxxxxxxx
10979                                                          st2h.  */
10980                                                       return 1929;
10981                                                     }
10982                                                 }
10983                                             }
10984                                           else
10985                                             {
10986                                               if (((word >> 23) & 0x1) == 0)
10987                                                 {
10988                                                   /* 33222222222211111111110000000000
10989                                                      10987654321098765432109876543210
10990                                                      x11001x0011xxxxx011xxxxxxxxxxxxx
10991                                                      st4b.  */
10992                                                   return 1941;
10993                                                 }
10994                                               else
10995                                                 {
10996                                                   /* 33222222222211111111110000000000
10997                                                      10987654321098765432109876543210
10998                                                      x11001x0111xxxxx011xxxxxxxxxxxxx
10999                                                      st4h.  */
11000                                                   return 1945;
11001                                                 }
11002                                             }
11003                                         }
11004                                       else
11005                                         {
11006                                           if (((word >> 22) & 0x1) == 0)
11007                                             {
11008                                               if (((word >> 23) & 0x1) == 0)
11009                                                 {
11010                                                   if (((word >> 20) & 0x1) == 0)
11011                                                     {
11012                                                       /* 33222222222211111111110000000000
11013                                                          10987654321098765432109876543210
11014                                                          x11001x00010xxxx111xxxxxxxxxxxxx
11015                                                          st1b.  */
11016                                                       return 1887;
11017                                                     }
11018                                                   else
11019                                                     {
11020                                                       /* 33222222222211111111110000000000
11021                                                          10987654321098765432109876543210
11022                                                          x11001x00011xxxx111xxxxxxxxxxxxx
11023                                                          st2b.  */
11024                                                       return 1926;
11025                                                     }
11026                                                 }
11027                                               else
11028                                                 {
11029                                                   if (((word >> 31) & 0x1) == 0)
11030                                                     {
11031                                                       /* 33222222222211111111110000000000
11032                                                          10987654321098765432109876543210
11033                                                          011001x0101xxxxx111xxxxxxxxxxxxx
11034                                                          fmmla.  */
11035                                                       return 2474;
11036                                                     }
11037                                                   else
11038                                                     {
11039                                                       if (((word >> 20) & 0x1) == 0)
11040                                                         {
11041                                                           /* 33222222222211111111110000000000
11042                                                              10987654321098765432109876543210
11043                                                              111001x01010xxxx111xxxxxxxxxxxxx
11044                                                              st1h.  */
11045                                                           return 1908;
11046                                                         }
11047                                                       else
11048                                                         {
11049                                                           /* 33222222222211111111110000000000
11050                                                              10987654321098765432109876543210
11051                                                              111001x01011xxxx111xxxxxxxxxxxxx
11052                                                              st2h.  */
11053                                                           return 1930;
11054                                                         }
11055                                                     }
11056                                                 }
11057                                             }
11058                                           else
11059                                             {
11060                                               if (((word >> 23) & 0x1) == 0)
11061                                                 {
11062                                                   if (((word >> 31) & 0x1) == 0)
11063                                                     {
11064                                                       /* 33222222222211111111110000000000
11065                                                          10987654321098765432109876543210
11066                                                          011001x0011xxxxx111xxxxxxxxxxxxx
11067                                                          bfmmla.  */
11068                                                       return 2498;
11069                                                     }
11070                                                   else
11071                                                     {
11072                                                       if (((word >> 20) & 0x1) == 0)
11073                                                         {
11074                                                           /* 33222222222211111111110000000000
11075                                                              10987654321098765432109876543210
11076                                                              111001x00110xxxx111xxxxxxxxxxxxx
11077                                                              st1b.  */
11078                                                           return 1891;
11079                                                         }
11080                                                       else
11081                                                         {
11082                                                           /* 33222222222211111111110000000000
11083                                                              10987654321098765432109876543210
11084                                                              111001x00111xxxx111xxxxxxxxxxxxx
11085                                                              st4b.  */
11086                                                           return 1942;
11087                                                         }
11088                                                     }
11089                                                 }
11090                                               else
11091                                                 {
11092                                                   if (((word >> 31) & 0x1) == 0)
11093                                                     {
11094                                                       /* 33222222222211111111110000000000
11095                                                          10987654321098765432109876543210
11096                                                          011001x0111xxxxx111xxxxxxxxxxxxx
11097                                                          fmmla.  */
11098                                                       return 2475;
11099                                                     }
11100                                                   else
11101                                                     {
11102                                                       if (((word >> 20) & 0x1) == 0)
11103                                                         {
11104                                                           /* 33222222222211111111110000000000
11105                                                              10987654321098765432109876543210
11106                                                              111001x01110xxxx111xxxxxxxxxxxxx
11107                                                              st1h.  */
11108                                                           return 1912;
11109                                                         }
11110                                                       else
11111                                                         {
11112                                                           /* 33222222222211111111110000000000
11113                                                              10987654321098765432109876543210
11114                                                              111001x01111xxxx111xxxxxxxxxxxxx
11115                                                              st4h.  */
11116                                                           return 1946;
11117                                                         }
11118                                                     }
11119                                                 }
11120                                             }
11121                                         }
11122                                     }
11123                                 }
11124                             }
11125                         }
11126                     }
11127                 }
11128               else
11129                 {
11130                   if (((word >> 29) & 0x1) == 0)
11131                     {
11132                       if (((word >> 30) & 0x1) == 0)
11133                         {
11134                           if (((word >> 31) & 0x1) == 0)
11135                             {
11136                               if (((word >> 21) & 0x1) == 0)
11137                                 {
11138                                   if (((word >> 20) & 0x1) == 0)
11139                                     {
11140                                       if (((word >> 22) & 0x1) == 0)
11141                                         {
11142                                           if (((word >> 23) & 0x1) == 0)
11143                                             {
11144                                               /* 33222222222211111111110000000000
11145                                                  10987654321098765432109876543210
11146                                                  000001x10000xxxxxxxxxxxxxxxxxxxx
11147                                                  orr.  */
11148                                               return 1771;
11149                                             }
11150                                           else
11151                                             {
11152                                               /* 33222222222211111111110000000000
11153                                                  10987654321098765432109876543210
11154                                                  000001x11000xxxxxxxxxxxxxxxxxxxx
11155                                                  and.  */
11156                                               return 1299;
11157                                             }
11158                                         }
11159                                       else
11160                                         {
11161                                           if (((word >> 23) & 0x1) == 0)
11162                                             {
11163                                               /* 33222222222211111111110000000000
11164                                                  10987654321098765432109876543210
11165                                                  000001x10100xxxxxxxxxxxxxxxxxxxx
11166                                                  eor.  */
11167                                               return 1386;
11168                                             }
11169                                           else
11170                                             {
11171                                               /* 33222222222211111111110000000000
11172                                                  10987654321098765432109876543210
11173                                                  000001x11100xxxxxxxxxxxxxxxxxxxx
11174                                                  dupm.  */
11175                                               return 1384;
11176                                             }
11177                                         }
11178                                     }
11179                                   else
11180                                     {
11181                                       if (((word >> 15) & 0x1) == 0)
11182                                         {
11183                                           /* 33222222222211111111110000000000
11184                                              10987654321098765432109876543210
11185                                              000001x1xx01xxxx0xxxxxxxxxxxxxxx
11186                                              cpy.  */
11187                                           return 1369;
11188                                         }
11189                                       else
11190                                         {
11191                                           /* 33222222222211111111110000000000
11192                                              10987654321098765432109876543210
11193                                              000001x1xx01xxxx1xxxxxxxxxxxxxxx
11194                                              fcpy.  */
11195                                           return 1416;
11196                                         }
11197                                     }
11198                                 }
11199                               else
11200                                 {
11201                                   if (((word >> 14) & 0x1) == 0)
11202                                     {
11203                                       if (((word >> 13) & 0x1) == 0)
11204                                         {
11205                                           if (((word >> 15) & 0x1) == 0)
11206                                             {
11207                                               if (((word >> 22) & 0x1) == 0)
11208                                                 {
11209                                                   if (((word >> 23) & 0x1) == 0)
11210                                                     {
11211                                                       /* 33222222222211111111110000000000
11212                                                          10987654321098765432109876543210
11213                                                          000001x1001xxxxx000xxxxxxxxxxxxx
11214                                                          ext.  */
11215                                                       return 1391;
11216                                                     }
11217                                                   else
11218                                                     {
11219                                                       if (((word >> 10) & 0x1) == 0)
11220                                                         {
11221                                                           if (((word >> 11) & 0x1) == 0)
11222                                                             {
11223                                                               /* 33222222222211111111110000000000
11224                                                                  10987654321098765432109876543210
11225                                                                  000001x1101xxxxx000x00xxxxxxxxxx
11226                                                                  zip1.  */
11227                                                               return 2484;
11228                                                             }
11229                                                           else
11230                                                             {
11231                                                               if (((word >> 12) & 0x1) == 0)
11232                                                                 {
11233                                                                   /* 33222222222211111111110000000000
11234                                                                      10987654321098765432109876543210
11235                                                                      000001x1101xxxxx000010xxxxxxxxxx
11236                                                                      uzp1.  */
11237                                                                   return 2486;
11238                                                                 }
11239                                                               else
11240                                                                 {
11241                                                                   /* 33222222222211111111110000000000
11242                                                                      10987654321098765432109876543210
11243                                                                      000001x1101xxxxx000110xxxxxxxxxx
11244                                                                      trn1.  */
11245                                                                   return 2488;
11246                                                                 }
11247                                                             }
11248                                                         }
11249                                                       else
11250                                                         {
11251                                                           if (((word >> 11) & 0x1) == 0)
11252                                                             {
11253                                                               /* 33222222222211111111110000000000
11254                                                                  10987654321098765432109876543210
11255                                                                  000001x1101xxxxx000x01xxxxxxxxxx
11256                                                                  zip2.  */
11257                                                               return 2485;
11258                                                             }
11259                                                           else
11260                                                             {
11261                                                               if (((word >> 12) & 0x1) == 0)
11262                                                                 {
11263                                                                   /* 33222222222211111111110000000000
11264                                                                      10987654321098765432109876543210
11265                                                                      000001x1101xxxxx000011xxxxxxxxxx
11266                                                                      uzp2.  */
11267                                                                   return 2487;
11268                                                                 }
11269                                                               else
11270                                                                 {
11271                                                                   /* 33222222222211111111110000000000
11272                                                                      10987654321098765432109876543210
11273                                                                      000001x1101xxxxx000111xxxxxxxxxx
11274                                                                      trn2.  */
11275                                                                   return 2489;
11276                                                                 }
11277                                                             }
11278                                                         }
11279                                                     }
11280                                                 }
11281                                               else
11282                                                 {
11283                                                   /* 33222222222211111111110000000000
11284                                                      10987654321098765432109876543210
11285                                                      000001x1x11xxxxx000xxxxxxxxxxxxx
11286                                                      ext.  */
11287                                                   return 2081;
11288                                                 }
11289                                             }
11290                                           else
11291                                             {
11292                                               if (((word >> 16) & 0x1) == 0)
11293                                                 {
11294                                                   if (((word >> 17) & 0x1) == 0)
11295                                                     {
11296                                                       if (((word >> 18) & 0x1) == 0)
11297                                                         {
11298                                                           if (((word >> 19) & 0x1) == 0)
11299                                                             {
11300                                                               /* 33222222222211111111110000000000
11301                                                                  10987654321098765432109876543210
11302                                                                  000001x1xx1x0000100xxxxxxxxxxxxx
11303                                                                  cpy.  */
11304                                                               return 1367;
11305                                                             }
11306                                                           else
11307                                                             {
11308                                                               /* 33222222222211111111110000000000
11309                                                                  10987654321098765432109876543210
11310                                                                  000001x1xx1x1000100xxxxxxxxxxxxx
11311                                                                  clasta.  */
11312                                                               return 1325;
11313                                                             }
11314                                                         }
11315                                                       else
11316                                                         {
11317                                                           if (((word >> 19) & 0x1) == 0)
11318                                                             {
11319                                                               /* 33222222222211111111110000000000
11320                                                                  10987654321098765432109876543210
11321                                                                  000001x1xx1x0100100xxxxxxxxxxxxx
11322                                                                  revb.  */
11323                                                               return 1819;
11324                                                             }
11325                                                           else
11326                                                             {
11327                                                               /* 33222222222211111111110000000000
11328                                                                  10987654321098765432109876543210
11329                                                                  000001x1xx1x1100100xxxxxxxxxxxxx
11330                                                                  splice.  */
11331                                                               return 1846;
11332                                                             }
11333                                                         }
11334                                                     }
11335                                                   else
11336                                                     {
11337                                                       if (((word >> 18) & 0x1) == 0)
11338                                                         {
11339                                                           if (((word >> 19) & 0x1) == 0)
11340                                                             {
11341                                                               /* 33222222222211111111110000000000
11342                                                                  10987654321098765432109876543210
11343                                                                  000001x1xx1x0010100xxxxxxxxxxxxx
11344                                                                  lasta.  */
11345                                                               return 1513;
11346                                                             }
11347                                                           else
11348                                                             {
11349                                                               /* 33222222222211111111110000000000
11350                                                                  10987654321098765432109876543210
11351                                                                  000001x1xx1x1010100xxxxxxxxxxxxx
11352                                                                  clasta.  */
11353                                                               return 1326;
11354                                                             }
11355                                                         }
11356                                                       else
11357                                                         {
11358                                                           if (((word >> 19) & 0x1) == 0)
11359                                                             {
11360                                                               /* 33222222222211111111110000000000
11361                                                                  10987654321098765432109876543210
11362                                                                  000001x1xx1x0110100xxxxxxxxxxxxx
11363                                                                  revw.  */
11364                                                               return 1821;
11365                                                             }
11366                                                           else
11367                                                             {
11368                                                               /* 33222222222211111111110000000000
11369                                                                  10987654321098765432109876543210
11370                                                                  000001x1xx1x1110100xxxxxxxxxxxxx
11371                                                                  revd.  */
11372                                                               return 2411;
11373                                                             }
11374                                                         }
11375                                                     }
11376                                                 }
11377                                               else
11378                                                 {
11379                                                   if (((word >> 17) & 0x1) == 0)
11380                                                     {
11381                                                       if (((word >> 18) & 0x1) == 0)
11382                                                         {
11383                                                           if (((word >> 19) & 0x1) == 0)
11384                                                             {
11385                                                               /* 33222222222211111111110000000000
11386                                                                  10987654321098765432109876543210
11387                                                                  000001x1xx1x0001100xxxxxxxxxxxxx
11388                                                                  compact.  */
11389                                                               return 1366;
11390                                                             }
11391                                                           else
11392                                                             {
11393                                                               /* 33222222222211111111110000000000
11394                                                                  10987654321098765432109876543210
11395                                                                  000001x1xx1x1001100xxxxxxxxxxxxx
11396                                                                  clastb.  */
11397                                                               return 1328;
11398                                                             }
11399                                                         }
11400                                                       else
11401                                                         {
11402                                                           if (((word >> 19) & 0x1) == 0)
11403                                                             {
11404                                                               /* 33222222222211111111110000000000
11405                                                                  10987654321098765432109876543210
11406                                                                  000001x1xx1x0101100xxxxxxxxxxxxx
11407                                                                  revh.  */
11408                                                               return 1820;
11409                                                             }
11410                                                           else
11411                                                             {
11412                                                               /* 33222222222211111111110000000000
11413                                                                  10987654321098765432109876543210
11414                                                                  000001x1xx1x1101100xxxxxxxxxxxxx
11415                                                                  splice.  */
11416                                                               return 2176;
11417                                                             }
11418                                                         }
11419                                                     }
11420                                                   else
11421                                                     {
11422                                                       if (((word >> 18) & 0x1) == 0)
11423                                                         {
11424                                                           if (((word >> 19) & 0x1) == 0)
11425                                                             {
11426                                                               /* 33222222222211111111110000000000
11427                                                                  10987654321098765432109876543210
11428                                                                  000001x1xx1x0011100xxxxxxxxxxxxx
11429                                                                  lastb.  */
11430                                                               return 1515;
11431                                                             }
11432                                                           else
11433                                                             {
11434                                                               /* 33222222222211111111110000000000
11435                                                                  10987654321098765432109876543210
11436                                                                  000001x1xx1x1011100xxxxxxxxxxxxx
11437                                                                  clastb.  */
11438                                                               return 1329;
11439                                                             }
11440                                                         }
11441                                                       else
11442                                                         {
11443                                                           /* 33222222222211111111110000000000
11444                                                              10987654321098765432109876543210
11445                                                              000001x1xx1xx111100xxxxxxxxxxxxx
11446                                                              rbit.  */
11447                                                           return 1812;
11448                                                         }
11449                                                     }
11450                                                 }
11451                                             }
11452                                         }
11453                                       else
11454                                         {
11455                                           if (((word >> 15) & 0x1) == 0)
11456                                             {
11457                                               if (((word >> 10) & 0x1) == 0)
11458                                                 {
11459                                                   if (((word >> 11) & 0x1) == 0)
11460                                                     {
11461                                                       if (((word >> 12) & 0x1) == 0)
11462                                                         {
11463                                                           /* 33222222222211111111110000000000
11464                                                              10987654321098765432109876543210
11465                                                              000001x1xx1xxxxx001000xxxxxxxxxx
11466                                                              dup.  */
11467                                                           return 1382;
11468                                                         }
11469                                                       else
11470                                                         {
11471                                                           /* 33222222222211111111110000000000
11472                                                              10987654321098765432109876543210
11473                                                              000001x1xx1xxxxx001100xxxxxxxxxx
11474                                                              tbl.  */
11475                                                           return 1969;
11476                                                         }
11477                                                     }
11478                                                   else
11479                                                     {
11480                                                       if (((word >> 12) & 0x1) == 0)
11481                                                         {
11482                                                           /* 33222222222211111111110000000000
11483                                                              10987654321098765432109876543210
11484                                                              000001x1xx1xxxxx001010xxxxxxxxxx
11485                                                              tbl.  */
11486                                                           return 2265;
11487                                                         }
11488                                                       else
11489                                                         {
11490                                                           if (((word >> 16) & 0x1) == 0)
11491                                                             {
11492                                                               if (((word >> 17) & 0x1) == 0)
11493                                                                 {
11494                                                                   if (((word >> 18) & 0x1) == 0)
11495                                                                     {
11496                                                                       if (((word >> 19) & 0x1) == 0)
11497                                                                         {
11498                                                                           if (((word >> 20) & 0x1) == 0)
11499                                                                             {
11500                                                                               /* 33222222222211111111110000000000
11501                                                                                  10987654321098765432109876543210
11502                                                                                  000001x1xx100000001110xxxxxxxxxx
11503                                                                                  dup.  */
11504                                                                               return 1381;
11505                                                                             }
11506                                                                           else
11507                                                                             {
11508                                                                               /* 33222222222211111111110000000000
11509                                                                                  10987654321098765432109876543210
11510                                                                                  000001x1xx110000001110xxxxxxxxxx
11511                                                                                  sunpklo.  */
11512                                                                               return 1965;
11513                                                                             }
11514                                                                         }
11515                                                                       else
11516                                                                         {
11517                                                                           /* 33222222222211111111110000000000
11518                                                                              10987654321098765432109876543210
11519                                                                              000001x1xx1x1000001110xxxxxxxxxx
11520                                                                              rev.  */
11521                                                                           return 1818;
11522                                                                         }
11523                                                                     }
11524                                                                   else
11525                                                                     {
11526                                                                       if (((word >> 20) & 0x1) == 0)
11527                                                                         {
11528                                                                           /* 33222222222211111111110000000000
11529                                                                              10987654321098765432109876543210
11530                                                                              000001x1xx10x100001110xxxxxxxxxx
11531                                                                              insr.  */
11532                                                                           return 1510;
11533                                                                         }
11534                                                                       else
11535                                                                         {
11536                                                                           /* 33222222222211111111110000000000
11537                                                                              10987654321098765432109876543210
11538                                                                              000001x1xx11x100001110xxxxxxxxxx
11539                                                                              insr.  */
11540                                                                           return 1511;
11541                                                                         }
11542                                                                     }
11543                                                                 }
11544                                                               else
11545                                                                 {
11546                                                                   /* 33222222222211111111110000000000
11547                                                                      10987654321098765432109876543210
11548                                                                      000001x1xx1xxx10001110xxxxxxxxxx
11549                                                                      uunpklo.  */
11550                                                                   return 2028;
11551                                                                 }
11552                                                             }
11553                                                           else
11554                                                             {
11555                                                               if (((word >> 17) & 0x1) == 0)
11556                                                                 {
11557                                                                   /* 33222222222211111111110000000000
11558                                                                      10987654321098765432109876543210
11559                                                                      000001x1xx1xxx01001110xxxxxxxxxx
11560                                                                      sunpkhi.  */
11561                                                                   return 1964;
11562                                                                 }
11563                                                               else
11564                                                                 {
11565                                                                   /* 33222222222211111111110000000000
11566                                                                      10987654321098765432109876543210
11567                                                                      000001x1xx1xxx11001110xxxxxxxxxx
11568                                                                      uunpkhi.  */
11569                                                                   return 2027;
11570                                                                 }
11571                                                             }
11572                                                         }
11573                                                     }
11574                                                 }
11575                                               else
11576                                                 {
11577                                                   /* 33222222222211111111110000000000
11578                                                      10987654321098765432109876543210
11579                                                      000001x1xx1xxxxx001xx1xxxxxxxxxx
11580                                                      tbx.  */
11581                                                   return 2266;
11582                                                 }
11583                                             }
11584                                           else
11585                                             {
11586                                               if (((word >> 16) & 0x1) == 0)
11587                                                 {
11588                                                   if (((word >> 19) & 0x1) == 0)
11589                                                     {
11590                                                       if (((word >> 20) & 0x1) == 0)
11591                                                         {
11592                                                           /* 33222222222211111111110000000000
11593                                                              10987654321098765432109876543210
11594                                                              000001x1xx100xx0101xxxxxxxxxxxxx
11595                                                              lasta.  */
11596                                                           return 1512;
11597                                                         }
11598                                                       else
11599                                                         {
11600                                                           /* 33222222222211111111110000000000
11601                                                              10987654321098765432109876543210
11602                                                              000001x1xx110xx0101xxxxxxxxxxxxx
11603                                                              clasta.  */
11604                                                           return 1327;
11605                                                         }
11606                                                     }
11607                                                   else
11608                                                     {
11609                                                       /* 33222222222211111111110000000000
11610                                                          10987654321098765432109876543210
11611                                                          000001x1xx1x1xx0101xxxxxxxxxxxxx
11612                                                          cpy.  */
11613                                                       return 1368;
11614                                                     }
11615                                                 }
11616                                               else
11617                                                 {
11618                                                   if (((word >> 20) & 0x1) == 0)
11619                                                     {
11620                                                       /* 33222222222211111111110000000000
11621                                                          10987654321098765432109876543210
11622                                                          000001x1xx10xxx1101xxxxxxxxxxxxx
11623                                                          lastb.  */
11624                                                       return 1514;
11625                                                     }
11626                                                   else
11627                                                     {
11628                                                       /* 33222222222211111111110000000000
11629                                                          10987654321098765432109876543210
11630                                                          000001x1xx11xxx1101xxxxxxxxxxxxx
11631                                                          clastb.  */
11632                                                       return 1330;
11633                                                     }
11634                                                 }
11635                                             }
11636                                         }
11637                                     }
11638                                   else
11639                                     {
11640                                       if (((word >> 15) & 0x1) == 0)
11641                                         {
11642                                           if (((word >> 10) & 0x1) == 0)
11643                                             {
11644                                               if (((word >> 11) & 0x1) == 0)
11645                                                 {
11646                                                   if (((word >> 12) & 0x1) == 0)
11647                                                     {
11648                                                       if (((word >> 13) & 0x1) == 0)
11649                                                         {
11650                                                           if (((word >> 20) & 0x1) == 0)
11651                                                             {
11652                                                               /* 33222222222211111111110000000000
11653                                                                  10987654321098765432109876543210
11654                                                                  000001x1xx10xxxx010000xxxxxxxxxx
11655                                                                  zip1.  */
11656                                                               return 2045;
11657                                                             }
11658                                                           else
11659                                                             {
11660                                                               if (((word >> 16) & 0x1) == 0)
11661                                                                 {
11662                                                                   if (((word >> 18) & 0x1) == 0)
11663                                                                     {
11664                                                                       /* 33222222222211111111110000000000
11665                                                                          10987654321098765432109876543210
11666                                                                          000001x1xx11x0x0010000xxxxxxxxxx
11667                                                                          punpklo.  */
11668                                                                       return 1811;
11669                                                                     }
11670                                                                   else
11671                                                                     {
11672                                                                       /* 33222222222211111111110000000000
11673                                                                          10987654321098765432109876543210
11674                                                                          000001x1xx11x1x0010000xxxxxxxxxx
11675                                                                          rev.  */
11676                                                                       return 1817;
11677                                                                     }
11678                                                                 }
11679                                                               else
11680                                                                 {
11681                                                                   /* 33222222222211111111110000000000
11682                                                                      10987654321098765432109876543210
11683                                                                      000001x1xx11xxx1010000xxxxxxxxxx
11684                                                                      punpkhi.  */
11685                                                                   return 1810;
11686                                                                 }
11687                                                             }
11688                                                         }
11689                                                       else
11690                                                         {
11691                                                           /* 33222222222211111111110000000000
11692                                                              10987654321098765432109876543210
11693                                                              000001x1xx1xxxxx011000xxxxxxxxxx
11694                                                              zip1.  */
11695                                                           return 2046;
11696                                                         }
11697                                                     }
11698                                                   else
11699                                                     {
11700                                                       if (((word >> 13) & 0x1) == 0)
11701                                                         {
11702                                                           /* 33222222222211111111110000000000
11703                                                              10987654321098765432109876543210
11704                                                              000001x1xx1xxxxx010100xxxxxxxxxx
11705                                                              trn1.  */
11706                                                           return 1970;
11707                                                         }
11708                                                       else
11709                                                         {
11710                                                           /* 33222222222211111111110000000000
11711                                                              10987654321098765432109876543210
11712                                                              000001x1xx1xxxxx011100xxxxxxxxxx
11713                                                              trn1.  */
11714                                                           return 1971;
11715                                                         }
11716                                                     }
11717                                                 }
11718                                               else
11719                                                 {
11720                                                   if (((word >> 13) & 0x1) == 0)
11721                                                     {
11722                                                       /* 33222222222211111111110000000000
11723                                                          10987654321098765432109876543210
11724                                                          000001x1xx1xxxxx010x10xxxxxxxxxx
11725                                                          uzp1.  */
11726                                                       return 2032;
11727                                                     }
11728                                                   else
11729                                                     {
11730                                                       /* 33222222222211111111110000000000
11731                                                          10987654321098765432109876543210
11732                                                          000001x1xx1xxxxx011x10xxxxxxxxxx
11733                                                          uzp1.  */
11734                                                       return 2033;
11735                                                     }
11736                                                 }
11737                                             }
11738                                           else
11739                                             {
11740                                               if (((word >> 11) & 0x1) == 0)
11741                                                 {
11742                                                   if (((word >> 12) & 0x1) == 0)
11743                                                     {
11744                                                       if (((word >> 13) & 0x1) == 0)
11745                                                         {
11746                                                           /* 33222222222211111111110000000000
11747                                                              10987654321098765432109876543210
11748                                                              000001x1xx1xxxxx010001xxxxxxxxxx
11749                                                              zip2.  */
11750                                                           return 2047;
11751                                                         }
11752                                                       else
11753                                                         {
11754                                                           /* 33222222222211111111110000000000
11755                                                              10987654321098765432109876543210
11756                                                              000001x1xx1xxxxx011001xxxxxxxxxx
11757                                                              zip2.  */
11758                                                           return 2048;
11759                                                         }
11760                                                     }
11761                                                   else
11762                                                     {
11763                                                       if (((word >> 13) & 0x1) == 0)
11764                                                         {
11765                                                           /* 33222222222211111111110000000000
11766                                                              10987654321098765432109876543210
11767                                                              000001x1xx1xxxxx010101xxxxxxxxxx
11768                                                              trn2.  */
11769                                                           return 1972;
11770                                                         }
11771                                                       else
11772                                                         {
11773                                                           /* 33222222222211111111110000000000
11774                                                              10987654321098765432109876543210
11775                                                              000001x1xx1xxxxx011101xxxxxxxxxx
11776                                                              trn2.  */
11777                                                           return 1973;
11778                                                         }
11779                                                     }
11780                                                 }
11781                                               else
11782                                                 {
11783                                                   if (((word >> 13) & 0x1) == 0)
11784                                                     {
11785                                                       /* 33222222222211111111110000000000
11786                                                          10987654321098765432109876543210
11787                                                          000001x1xx1xxxxx010x11xxxxxxxxxx
11788                                                          uzp2.  */
11789                                                       return 2034;
11790                                                     }
11791                                                   else
11792                                                     {
11793                                                       /* 33222222222211111111110000000000
11794                                                          10987654321098765432109876543210
11795                                                          000001x1xx1xxxxx011x11xxxxxxxxxx
11796                                                          uzp2.  */
11797                                                       return 2035;
11798                                                     }
11799                                                 }
11800                                             }
11801                                         }
11802                                       else
11803                                         {
11804                                           /* 33222222222211111111110000000000
11805                                              10987654321098765432109876543210
11806                                              000001x1xx1xxxxx11xxxxxxxxxxxxxx
11807                                              sel.  */
11808                                           return 1836;
11809                                         }
11810                                     }
11811                                 }
11812                             }
11813                           else
11814                             {
11815                               if (((word >> 13) & 0x1) == 0)
11816                                 {
11817                                   if (((word >> 14) & 0x1) == 0)
11818                                     {
11819                                       if (((word >> 15) & 0x1) == 0)
11820                                         {
11821                                           if (((word >> 22) & 0x1) == 0)
11822                                             {
11823                                               /* 33222222222211111111110000000000
11824                                                  10987654321098765432109876543210
11825                                                  100001x1x0xxxxxx000xxxxxxxxxxxxx
11826                                                  ldr.  */
11827                                               return 1740;
11828                                             }
11829                                           else
11830                                             {
11831                                               /* 33222222222211111111110000000000
11832                                                  10987654321098765432109876543210
11833                                                  100001x1x1xxxxxx000xxxxxxxxxxxxx
11834                                                  prfb.  */
11835                                               return 1784;
11836                                             }
11837                                         }
11838                                       else
11839                                         {
11840                                           if (((word >> 23) & 0x1) == 0)
11841                                             {
11842                                               /* 33222222222211111111110000000000
11843                                                  10987654321098765432109876543210
11844                                                  100001x10xxxxxxx100xxxxxxxxxxxxx
11845                                                  ld1rsh.  */
11846                                               return 1569;
11847                                             }
11848                                           else
11849                                             {
11850                                               /* 33222222222211111111110000000000
11851                                                  10987654321098765432109876543210
11852                                                  100001x11xxxxxxx100xxxxxxxxxxxxx
11853                                                  ld1rsb.  */
11854                                               return 1566;
11855                                             }
11856                                         }
11857                                     }
11858                                   else
11859                                     {
11860                                       if (((word >> 15) & 0x1) == 0)
11861                                         {
11862                                           if (((word >> 23) & 0x1) == 0)
11863                                             {
11864                                               if (((word >> 21) & 0x1) == 0)
11865                                                 {
11866                                                   /* 33222222222211111111110000000000
11867                                                      10987654321098765432109876543210
11868                                                      100001x10x0xxxxx010xxxxxxxxxxxxx
11869                                                      ld1w.  */
11870                                                   return 1604;
11871                                                 }
11872                                               else
11873                                                 {
11874                                                   /* 33222222222211111111110000000000
11875                                                      10987654321098765432109876543210
11876                                                      100001x10x1xxxxx010xxxxxxxxxxxxx
11877                                                      ld1w.  */
11878                                                   return 1605;
11879                                                 }
11880                                             }
11881                                           else
11882                                             {
11883                                               if (((word >> 22) & 0x1) == 0)
11884                                                 {
11885                                                   /* 33222222222211111111110000000000
11886                                                      10987654321098765432109876543210
11887                                                      100001x110xxxxxx010xxxxxxxxxxxxx
11888                                                      ldr.  */
11889                                                   return 1741;
11890                                                 }
11891                                               else
11892                                                 {
11893                                                   /* 33222222222211111111110000000000
11894                                                      10987654321098765432109876543210
11895                                                      100001x111xxxxxx010xxxxxxxxxxxxx
11896                                                      prfw.  */
11897                                                   return 1805;
11898                                                 }
11899                                             }
11900                                         }
11901                                       else
11902                                         {
11903                                           if (((word >> 22) & 0x1) == 0)
11904                                             {
11905                                               if (((word >> 21) & 0x1) == 0)
11906                                                 {
11907                                                   if (((word >> 23) & 0x1) == 0)
11908                                                     {
11909                                                       /* 33222222222211111111110000000000
11910                                                          10987654321098765432109876543210
11911                                                          100001x1000xxxxx110xxxxxxxxxxxxx
11912                                                          prfw.  */
11913                                                       return 1801;
11914                                                     }
11915                                                   else
11916                                                     {
11917                                                       /* 33222222222211111111110000000000
11918                                                          10987654321098765432109876543210
11919                                                          100001x1100xxxxx110xxxxxxxxxxxxx
11920                                                          prfd.  */
11921                                                       return 1787;
11922                                                     }
11923                                                 }
11924                                               else
11925                                                 {
11926                                                   /* 33222222222211111111110000000000
11927                                                      10987654321098765432109876543210
11928                                                      100001x1x01xxxxx110xxxxxxxxxxxxx
11929                                                      ld1w.  */
11930                                                   return 1612;
11931                                                 }
11932                                             }
11933                                           else
11934                                             {
11935                                               if (((word >> 23) & 0x1) == 0)
11936                                                 {
11937                                                   /* 33222222222211111111110000000000
11938                                                      10987654321098765432109876543210
11939                                                      100001x101xxxxxx110xxxxxxxxxxxxx
11940                                                      ld1rw.  */
11941                                                   return 1572;
11942                                                 }
11943                                               else
11944                                                 {
11945                                                   /* 33222222222211111111110000000000
11946                                                      10987654321098765432109876543210
11947                                                      100001x111xxxxxx110xxxxxxxxxxxxx
11948                                                      ld1rsb.  */
11949                                                   return 1568;
11950                                                 }
11951                                             }
11952                                         }
11953                                     }
11954                                 }
11955                               else
11956                                 {
11957                                   if (((word >> 14) & 0x1) == 0)
11958                                     {
11959                                       if (((word >> 15) & 0x1) == 0)
11960                                         {
11961                                           /* 33222222222211111111110000000000
11962                                              10987654321098765432109876543210
11963                                              100001x1xxxxxxxx001xxxxxxxxxxxxx
11964                                              prfh.  */
11965                                           return 1798;
11966                                         }
11967                                       else
11968                                         {
11969                                           if (((word >> 22) & 0x1) == 0)
11970                                             {
11971                                               /* 33222222222211111111110000000000
11972                                                  10987654321098765432109876543210
11973                                                  100001x1x0xxxxxx101xxxxxxxxxxxxx
11974                                                  ldnt1w.  */
11975                                               return 2112;
11976                                             }
11977                                           else
11978                                             {
11979                                               if (((word >> 23) & 0x1) == 0)
11980                                                 {
11981                                                   /* 33222222222211111111110000000000
11982                                                      10987654321098765432109876543210
11983                                                      100001x101xxxxxx101xxxxxxxxxxxxx
11984                                                      ld1rsh.  */
11985                                                   return 1570;
11986                                                 }
11987                                               else
11988                                                 {
11989                                                   /* 33222222222211111111110000000000
11990                                                      10987654321098765432109876543210
11991                                                      100001x111xxxxxx101xxxxxxxxxxxxx
11992                                                      ld1rsb.  */
11993                                                   return 1567;
11994                                                 }
11995                                             }
11996                                         }
11997                                     }
11998                                   else
11999                                     {
12000                                       if (((word >> 15) & 0x1) == 0)
12001                                         {
12002                                           if (((word >> 23) & 0x1) == 0)
12003                                             {
12004                                               if (((word >> 21) & 0x1) == 0)
12005                                                 {
12006                                                   /* 33222222222211111111110000000000
12007                                                      10987654321098765432109876543210
12008                                                      100001x10x0xxxxx011xxxxxxxxxxxxx
12009                                                      ldff1w.  */
12010                                                   return 1704;
12011                                                 }
12012                                               else
12013                                                 {
12014                                                   /* 33222222222211111111110000000000
12015                                                      10987654321098765432109876543210
12016                                                      100001x10x1xxxxx011xxxxxxxxxxxxx
12017                                                      ldff1w.  */
12018                                                   return 1705;
12019                                                 }
12020                                             }
12021                                           else
12022                                             {
12023                                               /* 33222222222211111111110000000000
12024                                                  10987654321098765432109876543210
12025                                                  100001x11xxxxxxx011xxxxxxxxxxxxx
12026                                                  prfd.  */
12027                                               return 1791;
12028                                             }
12029                                         }
12030                                       else
12031                                         {
12032                                           if (((word >> 22) & 0x1) == 0)
12033                                             {
12034                                               if (((word >> 21) & 0x1) == 0)
12035                                                 {
12036                                                   if (((word >> 23) & 0x1) == 0)
12037                                                     {
12038                                                       /* 33222222222211111111110000000000
12039                                                          10987654321098765432109876543210
12040                                                          100001x1000xxxxx111xxxxxxxxxxxxx
12041                                                          prfw.  */
12042                                                       return 1804;
12043                                                     }
12044                                                   else
12045                                                     {
12046                                                       /* 33222222222211111111110000000000
12047                                                          10987654321098765432109876543210
12048                                                          100001x1100xxxxx111xxxxxxxxxxxxx
12049                                                          prfd.  */
12050                                                       return 1790;
12051                                                     }
12052                                                 }
12053                                               else
12054                                                 {
12055                                                   /* 33222222222211111111110000000000
12056                                                      10987654321098765432109876543210
12057                                                      100001x1x01xxxxx111xxxxxxxxxxxxx
12058                                                      ldff1w.  */
12059                                                   return 1714;
12060                                                 }
12061                                             }
12062                                           else
12063                                             {
12064                                               if (((word >> 23) & 0x1) == 0)
12065                                                 {
12066                                                   /* 33222222222211111111110000000000
12067                                                      10987654321098765432109876543210
12068                                                      100001x101xxxxxx111xxxxxxxxxxxxx
12069                                                      ld1rw.  */
12070                                                   return 1573;
12071                                                 }
12072                                               else
12073                                                 {
12074                                                   /* 33222222222211111111110000000000
12075                                                      10987654321098765432109876543210
12076                                                      100001x111xxxxxx111xxxxxxxxxxxxx
12077                                                      ld1rd.  */
12078                                                   return 1554;
12079                                                 }
12080                                             }
12081                                         }
12082                                     }
12083                                 }
12084                             }
12085                         }
12086                       else
12087                         {
12088                           if (((word >> 13) & 0x1) == 0)
12089                             {
12090                               if (((word >> 14) & 0x1) == 0)
12091                                 {
12092                                   if (((word >> 15) & 0x1) == 0)
12093                                     {
12094                                       if (((word >> 21) & 0x1) == 0)
12095                                         {
12096                                           if (((word >> 31) & 0x1) == 0)
12097                                             {
12098                                               if (((word >> 10) & 0x1) == 0)
12099                                                 {
12100                                                   if (((word >> 11) & 0x1) == 0)
12101                                                     {
12102                                                       if (((word >> 12) & 0x1) == 0)
12103                                                         {
12104                                                           /* 33222222222211111111110000000000
12105                                                              10987654321098765432109876543210
12106                                                              010001x1xx0xxxxx000000xxxxxxxxxx
12107                                                              saddlb.  */
12108                                                           return 2142;
12109                                                         }
12110                                                       else
12111                                                         {
12112                                                           /* 33222222222211111111110000000000
12113                                                              10987654321098765432109876543210
12114                                                              010001x1xx0xxxxx000100xxxxxxxxxx
12115                                                              ssublb.  */
12116                                                           return 2249;
12117                                                         }
12118                                                     }
12119                                                   else
12120                                                     {
12121                                                       if (((word >> 12) & 0x1) == 0)
12122                                                         {
12123                                                           /* 33222222222211111111110000000000
12124                                                              10987654321098765432109876543210
12125                                                              010001x1xx0xxxxx000010xxxxxxxxxx
12126                                                              uaddlb.  */
12127                                                           return 2273;
12128                                                         }
12129                                                       else
12130                                                         {
12131                                                           /* 33222222222211111111110000000000
12132                                                              10987654321098765432109876543210
12133                                                              010001x1xx0xxxxx000110xxxxxxxxxx
12134                                                              usublb.  */
12135                                                           return 2326;
12136                                                         }
12137                                                     }
12138                                                 }
12139                                               else
12140                                                 {
12141                                                   if (((word >> 11) & 0x1) == 0)
12142                                                     {
12143                                                       if (((word >> 12) & 0x1) == 0)
12144                                                         {
12145                                                           /* 33222222222211111111110000000000
12146                                                              10987654321098765432109876543210
12147                                                              010001x1xx0xxxxx000001xxxxxxxxxx
12148                                                              saddlt.  */
12149                                                           return 2144;
12150                                                         }
12151                                                       else
12152                                                         {
12153                                                           /* 33222222222211111111110000000000
12154                                                              10987654321098765432109876543210
12155                                                              010001x1xx0xxxxx000101xxxxxxxxxx
12156                                                              ssublt.  */
12157                                                           return 2251;
12158                                                         }
12159                                                     }
12160                                                   else
12161                                                     {
12162                                                       if (((word >> 12) & 0x1) == 0)
12163                                                         {
12164                                                           /* 33222222222211111111110000000000
12165                                                              10987654321098765432109876543210
12166                                                              010001x1xx0xxxxx000011xxxxxxxxxx
12167                                                              uaddlt.  */
12168                                                           return 2274;
12169                                                         }
12170                                                       else
12171                                                         {
12172                                                           /* 33222222222211111111110000000000
12173                                                              10987654321098765432109876543210
12174                                                              010001x1xx0xxxxx000111xxxxxxxxxx
12175                                                              usublt.  */
12176                                                           return 2327;
12177                                                         }
12178                                                     }
12179                                                 }
12180                                             }
12181                                           else
12182                                             {
12183                                               /* 33222222222211111111110000000000
12184                                                  10987654321098765432109876543210
12185                                                  110001x1xx0xxxxx000xxxxxxxxxxxxx
12186                                                  ld1sw.  */
12187                                               return 1598;
12188                                             }
12189                                         }
12190                                       else
12191                                         {
12192                                           if (((word >> 31) & 0x1) == 0)
12193                                             {
12194                                               if (((word >> 10) & 0x1) == 0)
12195                                                 {
12196                                                   if (((word >> 11) & 0x1) == 0)
12197                                                     {
12198                                                       if (((word >> 12) & 0x1) == 0)
12199                                                         {
12200                                                           /* 33222222222211111111110000000000
12201                                                              10987654321098765432109876543210
12202                                                              010001x1xx1xxxxx000000xxxxxxxxxx
12203                                                              sqshrunb.  */
12204                                                           return 2232;
12205                                                         }
12206                                                       else
12207                                                         {
12208                                                           /* 33222222222211111111110000000000
12209                                                              10987654321098765432109876543210
12210                                                              010001x1xx1xxxxx000100xxxxxxxxxx
12211                                                              shrnb.  */
12212                                                           return 2150;
12213                                                         }
12214                                                     }
12215                                                   else
12216                                                     {
12217                                                       if (((word >> 12) & 0x1) == 0)
12218                                                         {
12219                                                           /* 33222222222211111111110000000000
12220                                                              10987654321098765432109876543210
12221                                                              010001x1xx1xxxxx000010xxxxxxxxxx
12222                                                              sqrshrunb.  */
12223                                                           return 2224;
12224                                                         }
12225                                                       else
12226                                                         {
12227                                                           /* 33222222222211111111110000000000
12228                                                              10987654321098765432109876543210
12229                                                              010001x1xx1xxxxx000110xxxxxxxxxx
12230                                                              rshrnb.  */
12231                                                           return 2132;
12232                                                         }
12233                                                     }
12234                                                 }
12235                                               else
12236                                                 {
12237                                                   if (((word >> 11) & 0x1) == 0)
12238                                                     {
12239                                                       if (((word >> 12) & 0x1) == 0)
12240                                                         {
12241                                                           /* 33222222222211111111110000000000
12242                                                              10987654321098765432109876543210
12243                                                              010001x1xx1xxxxx000001xxxxxxxxxx
12244                                                              sqshrunt.  */
12245                                                           return 2233;
12246                                                         }
12247                                                       else
12248                                                         {
12249                                                           /* 33222222222211111111110000000000
12250                                                              10987654321098765432109876543210
12251                                                              010001x1xx1xxxxx000101xxxxxxxxxx
12252                                                              shrnt.  */
12253                                                           return 2151;
12254                                                         }
12255                                                     }
12256                                                   else
12257                                                     {
12258                                                       if (((word >> 12) & 0x1) == 0)
12259                                                         {
12260                                                           /* 33222222222211111111110000000000
12261                                                              10987654321098765432109876543210
12262                                                              010001x1xx1xxxxx000011xxxxxxxxxx
12263                                                              sqrshrunt.  */
12264                                                           return 2225;
12265                                                         }
12266                                                       else
12267                                                         {
12268                                                           /* 33222222222211111111110000000000
12269                                                              10987654321098765432109876543210
12270                                                              010001x1xx1xxxxx000111xxxxxxxxxx
12271                                                              rshrnt.  */
12272                                                           return 2133;
12273                                                         }
12274                                                     }
12275                                                 }
12276                                             }
12277                                           else
12278                                             {
12279                                               /* 33222222222211111111110000000000
12280                                                  10987654321098765432109876543210
12281                                                  110001x1xx1xxxxx000xxxxxxxxxxxxx
12282                                                  ld1sw.  */
12283                                               return 1599;
12284                                             }
12285                                         }
12286                                     }
12287                                   else
12288                                     {
12289                                       if (((word >> 21) & 0x1) == 0)
12290                                         {
12291                                           if (((word >> 31) & 0x1) == 0)
12292                                             {
12293                                               if (((word >> 10) & 0x1) == 0)
12294                                                 {
12295                                                   if (((word >> 11) & 0x1) == 0)
12296                                                     {
12297                                                       if (((word >> 12) & 0x1) == 0)
12298                                                         {
12299                                                           /* 33222222222211111111110000000000
12300                                                              10987654321098765432109876543210
12301                                                              010001x1xx0xxxxx100000xxxxxxxxxx
12302                                                              saddlbt.  */
12303                                                           return 2143;
12304                                                         }
12305                                                       else
12306                                                         {
12307                                                           /* 33222222222211111111110000000000
12308                                                              10987654321098765432109876543210
12309                                                              010001x1xx0xxxxx100100xxxxxxxxxx
12310                                                              eorbt.  */
12311                                                           return 2079;
12312                                                         }
12313                                                     }
12314                                                   else
12315                                                     {
12316                                                       if (((word >> 12) & 0x1) == 0)
12317                                                         {
12318                                                           /* 33222222222211111111110000000000
12319                                                              10987654321098765432109876543210
12320                                                              010001x1xx0xxxxx100010xxxxxxxxxx
12321                                                              ssublbt.  */
12322                                                           return 2250;
12323                                                         }
12324                                                       else
12325                                                         {
12326                                                           if (((word >> 22) & 0x1) == 0)
12327                                                             {
12328                                                               if (((word >> 23) & 0x1) == 0)
12329                                                                 {
12330                                                                   /* 33222222222211111111110000000000
12331                                                                      10987654321098765432109876543210
12332                                                                      010001x1000xxxxx100110xxxxxxxxxx
12333                                                                      smmla.  */
12334                                                                   return 2468;
12335                                                                 }
12336                                                               else
12337                                                                 {
12338                                                                   /* 33222222222211111111110000000000
12339                                                                      10987654321098765432109876543210
12340                                                                      010001x1100xxxxx100110xxxxxxxxxx
12341                                                                      usmmla.  */
12342                                                                   return 2470;
12343                                                                 }
12344                                                             }
12345                                                           else
12346                                                             {
12347                                                               /* 33222222222211111111110000000000
12348                                                                  10987654321098765432109876543210
12349                                                                  010001x1x10xxxxx100110xxxxxxxxxx
12350                                                                  ummla.  */
12351                                                               return 2469;
12352                                                             }
12353                                                         }
12354                                                     }
12355                                                 }
12356                                               else
12357                                                 {
12358                                                   if (((word >> 11) & 0x1) == 0)
12359                                                     {
12360                                                       /* 33222222222211111111110000000000
12361                                                          10987654321098765432109876543210
12362                                                          010001x1xx0xxxxx100x01xxxxxxxxxx
12363                                                          eortb.  */
12364                                                       return 2080;
12365                                                     }
12366                                                   else
12367                                                     {
12368                                                       /* 33222222222211111111110000000000
12369                                                          10987654321098765432109876543210
12370                                                          010001x1xx0xxxxx100x11xxxxxxxxxx
12371                                                          ssubltb.  */
12372                                                       return 2252;
12373                                                     }
12374                                                 }
12375                                             }
12376                                           else
12377                                             {
12378                                               if (((word >> 22) & 0x1) == 0)
12379                                                 {
12380                                                   /* 33222222222211111111110000000000
12381                                                      10987654321098765432109876543210
12382                                                      110001x1x00xxxxx100xxxxxxxxxxxxx
12383                                                      ldnt1sw.  */
12384                                                   return 2111;
12385                                                 }
12386                                               else
12387                                                 {
12388                                                   /* 33222222222211111111110000000000
12389                                                      10987654321098765432109876543210
12390                                                      110001x1x10xxxxx100xxxxxxxxxxxxx
12391                                                      ld1sw.  */
12392                                                   return 1600;
12393                                                 }
12394                                             }
12395                                         }
12396                                       else
12397                                         {
12398                                           if (((word >> 31) & 0x1) == 0)
12399                                             {
12400                                               if (((word >> 4) & 0x1) == 0)
12401                                                 {
12402                                                   /* 33222222222211111111110000000000
12403                                                      10987654321098765432109876543210
12404                                                      010001x1xx1xxxxx100xxxxxxxx0xxxx
12405                                                      match.  */
12406                                                   return 2114;
12407                                                 }
12408                                               else
12409                                                 {
12410                                                   /* 33222222222211111111110000000000
12411                                                      10987654321098765432109876543210
12412                                                      010001x1xx1xxxxx100xxxxxxxx1xxxx
12413                                                      nmatch.  */
12414                                                   return 2126;
12415                                                 }
12416                                             }
12417                                           else
12418                                             {
12419                                               if (((word >> 22) & 0x1) == 0)
12420                                                 {
12421                                                   /* 33222222222211111111110000000000
12422                                                      10987654321098765432109876543210
12423                                                      110001x1x01xxxxx100xxxxxxxxxxxxx
12424                                                      ld1sw.  */
12425                                                   return 1603;
12426                                                 }
12427                                               else
12428                                                 {
12429                                                   /* 33222222222211111111110000000000
12430                                                      10987654321098765432109876543210
12431                                                      110001x1x11xxxxx100xxxxxxxxxxxxx
12432                                                      ld1sw.  */
12433                                                   return 1601;
12434                                                 }
12435                                             }
12436                                         }
12437                                     }
12438                                 }
12439                               else
12440                                 {
12441                                   if (((word >> 15) & 0x1) == 0)
12442                                     {
12443                                       if (((word >> 21) & 0x1) == 0)
12444                                         {
12445                                           if (((word >> 31) & 0x1) == 0)
12446                                             {
12447                                               if (((word >> 10) & 0x1) == 0)
12448                                                 {
12449                                                   if (((word >> 11) & 0x1) == 0)
12450                                                     {
12451                                                       if (((word >> 12) & 0x1) == 0)
12452                                                         {
12453                                                           /* 33222222222211111111110000000000
12454                                                              10987654321098765432109876543210
12455                                                              010001x1xx0xxxxx010000xxxxxxxxxx
12456                                                              saddwb.  */
12457                                                           return 2145;
12458                                                         }
12459                                                       else
12460                                                         {
12461                                                           /* 33222222222211111111110000000000
12462                                                              10987654321098765432109876543210
12463                                                              010001x1xx0xxxxx010100xxxxxxxxxx
12464                                                              ssubwb.  */
12465                                                           return 2253;
12466                                                         }
12467                                                     }
12468                                                   else
12469                                                     {
12470                                                       if (((word >> 12) & 0x1) == 0)
12471                                                         {
12472                                                           /* 33222222222211111111110000000000
12473                                                              10987654321098765432109876543210
12474                                                              010001x1xx0xxxxx010010xxxxxxxxxx
12475                                                              uaddwb.  */
12476                                                           return 2275;
12477                                                         }
12478                                                       else
12479                                                         {
12480                                                           /* 33222222222211111111110000000000
12481                                                              10987654321098765432109876543210
12482                                                              010001x1xx0xxxxx010110xxxxxxxxxx
12483                                                              usubwb.  */
12484                                                           return 2328;
12485                                                         }
12486                                                     }
12487                                                 }
12488                                               else
12489                                                 {
12490                                                   if (((word >> 11) & 0x1) == 0)
12491                                                     {
12492                                                       if (((word >> 12) & 0x1) == 0)
12493                                                         {
12494                                                           /* 33222222222211111111110000000000
12495                                                              10987654321098765432109876543210
12496                                                              010001x1xx0xxxxx010001xxxxxxxxxx
12497                                                              saddwt.  */
12498                                                           return 2146;
12499                                                         }
12500                                                       else
12501                                                         {
12502                                                           /* 33222222222211111111110000000000
12503                                                              10987654321098765432109876543210
12504                                                              010001x1xx0xxxxx010101xxxxxxxxxx
12505                                                              ssubwt.  */
12506                                                           return 2254;
12507                                                         }
12508                                                     }
12509                                                   else
12510                                                     {
12511                                                       if (((word >> 12) & 0x1) == 0)
12512                                                         {
12513                                                           /* 33222222222211111111110000000000
12514                                                              10987654321098765432109876543210
12515                                                              010001x1xx0xxxxx010011xxxxxxxxxx
12516                                                              uaddwt.  */
12517                                                           return 2276;
12518                                                         }
12519                                                       else
12520                                                         {
12521                                                           /* 33222222222211111111110000000000
12522                                                              10987654321098765432109876543210
12523                                                              010001x1xx0xxxxx010111xxxxxxxxxx
12524                                                              usubwt.  */
12525                                                           return 2329;
12526                                                         }
12527                                                     }
12528                                                 }
12529                                             }
12530                                           else
12531                                             {
12532                                               if (((word >> 23) & 0x1) == 0)
12533                                                 {
12534                                                   /* 33222222222211111111110000000000
12535                                                      10987654321098765432109876543210
12536                                                      110001x10x0xxxxx010xxxxxxxxxxxxx
12537                                                      ld1w.  */
12538                                                   return 1608;
12539                                                 }
12540                                               else
12541                                                 {
12542                                                   /* 33222222222211111111110000000000
12543                                                      10987654321098765432109876543210
12544                                                      110001x11x0xxxxx010xxxxxxxxxxxxx
12545                                                      ld1d.  */
12546                                                   return 1530;
12547                                                 }
12548                                             }
12549                                         }
12550                                       else
12551                                         {
12552                                           if (((word >> 23) & 0x1) == 0)
12553                                             {
12554                                               if (((word >> 31) & 0x1) == 0)
12555                                                 {
12556                                                   if (((word >> 10) & 0x1) == 0)
12557                                                     {
12558                                                       if (((word >> 11) & 0x1) == 0)
12559                                                         {
12560                                                           if (((word >> 12) & 0x1) == 0)
12561                                                             {
12562                                                               /* 33222222222211111111110000000000
12563                                                                  10987654321098765432109876543210
12564                                                                  010001x10x1xxxxx010000xxxxxxxxxx
12565                                                                  sqxtnb.  */
12566                                                               return 2236;
12567                                                             }
12568                                                           else
12569                                                             {
12570                                                               /* 33222222222211111111110000000000
12571                                                                  10987654321098765432109876543210
12572                                                                  010001x10x1xxxxx010100xxxxxxxxxx
12573                                                                  sqxtunb.  */
12574                                                               return 2238;
12575                                                             }
12576                                                         }
12577                                                       else
12578                                                         {
12579                                                           /* 33222222222211111111110000000000
12580                                                              10987654321098765432109876543210
12581                                                              010001x10x1xxxxx010x10xxxxxxxxxx
12582                                                              uqxtnb.  */
12583                                                           return 2313;
12584                                                         }
12585                                                     }
12586                                                   else
12587                                                     {
12588                                                       if (((word >> 11) & 0x1) == 0)
12589                                                         {
12590                                                           if (((word >> 12) & 0x1) == 0)
12591                                                             {
12592                                                               /* 33222222222211111111110000000000
12593                                                                  10987654321098765432109876543210
12594                                                                  010001x10x1xxxxx010001xxxxxxxxxx
12595                                                                  sqxtnt.  */
12596                                                               return 2237;
12597                                                             }
12598                                                           else
12599                                                             {
12600                                                               /* 33222222222211111111110000000000
12601                                                                  10987654321098765432109876543210
12602                                                                  010001x10x1xxxxx010101xxxxxxxxxx
12603                                                                  sqxtunt.  */
12604                                                               return 2239;
12605                                                             }
12606                                                         }
12607                                                       else
12608                                                         {
12609                                                           /* 33222222222211111111110000000000
12610                                                              10987654321098765432109876543210
12611                                                              010001x10x1xxxxx010x11xxxxxxxxxx
12612                                                              uqxtnt.  */
12613                                                           return 2314;
12614                                                         }
12615                                                     }
12616                                                 }
12617                                               else
12618                                                 {
12619                                                   /* 33222222222211111111110000000000
12620                                                      10987654321098765432109876543210
12621                                                      110001x10x1xxxxx010xxxxxxxxxxxxx
12622                                                      ld1w.  */
12623                                                   return 1609;
12624                                                 }
12625                                             }
12626                                           else
12627                                             {
12628                                               /* 33222222222211111111110000000000
12629                                                  10987654321098765432109876543210
12630                                                  x10001x11x1xxxxx010xxxxxxxxxxxxx
12631                                                  ld1d.  */
12632                                               return 1531;
12633                                             }
12634                                         }
12635                                     }
12636                                   else
12637                                     {
12638                                       if (((word >> 21) & 0x1) == 0)
12639                                         {
12640                                           if (((word >> 31) & 0x1) == 0)
12641                                             {
12642                                               if (((word >> 11) & 0x1) == 0)
12643                                                 {
12644                                                   if (((word >> 10) & 0x1) == 0)
12645                                                     {
12646                                                       if (((word >> 12) & 0x1) == 0)
12647                                                         {
12648                                                           /* 33222222222211111111110000000000
12649                                                              10987654321098765432109876543210
12650                                                              010001x1xx0xxxxx110000xxxxxxxxxx
12651                                                              sabalb.  */
12652                                                           return 2137;
12653                                                         }
12654                                                       else
12655                                                         {
12656                                                           if (((word >> 23) & 0x1) == 0)
12657                                                             {
12658                                                               /* 33222222222211111111110000000000
12659                                                                  10987654321098765432109876543210
12660                                                                  010001x10x0xxxxx110100xxxxxxxxxx
12661                                                                  adclb.  */
12662                                                               return 2062;
12663                                                             }
12664                                                           else
12665                                                             {
12666                                                               /* 33222222222211111111110000000000
12667                                                                  10987654321098765432109876543210
12668                                                                  010001x11x0xxxxx110100xxxxxxxxxx
12669                                                                  sbclb.  */
12670                                                               return 2147;
12671                                                             }
12672                                                         }
12673                                                     }
12674                                                   else
12675                                                     {
12676                                                       if (((word >> 12) & 0x1) == 0)
12677                                                         {
12678                                                           /* 33222222222211111111110000000000
12679                                                              10987654321098765432109876543210
12680                                                              010001x1xx0xxxxx110001xxxxxxxxxx
12681                                                              sabalt.  */
12682                                                           return 2138;
12683                                                         }
12684                                                       else
12685                                                         {
12686                                                           if (((word >> 23) & 0x1) == 0)
12687                                                             {
12688                                                               /* 33222222222211111111110000000000
12689                                                                  10987654321098765432109876543210
12690                                                                  010001x10x0xxxxx110101xxxxxxxxxx
12691                                                                  adclt.  */
12692                                                               return 2063;
12693                                                             }
12694                                                           else
12695                                                             {
12696                                                               /* 33222222222211111111110000000000
12697                                                                  10987654321098765432109876543210
12698                                                                  010001x11x0xxxxx110101xxxxxxxxxx
12699                                                                  sbclt.  */
12700                                                               return 2148;
12701                                                             }
12702                                                         }
12703                                                     }
12704                                                 }
12705                                               else
12706                                                 {
12707                                                   if (((word >> 12) & 0x1) == 0)
12708                                                     {
12709                                                       if (((word >> 10) & 0x1) == 0)
12710                                                         {
12711                                                           /* 33222222222211111111110000000000
12712                                                              10987654321098765432109876543210
12713                                                              010001x1xx0xxxxx110010xxxxxxxxxx
12714                                                              uabalb.  */
12715                                                           return 2268;
12716                                                         }
12717                                                       else
12718                                                         {
12719                                                           /* 33222222222211111111110000000000
12720                                                              10987654321098765432109876543210
12721                                                              010001x1xx0xxxxx110011xxxxxxxxxx
12722                                                              uabalt.  */
12723                                                           return 2269;
12724                                                         }
12725                                                     }
12726                                                   else
12727                                                     {
12728                                                       if (((word >> 16) & 0x1) == 0)
12729                                                         {
12730                                                           /* 33222222222211111111110000000000
12731                                                              10987654321098765432109876543210
12732                                                              010001x1xx0xxxx011011xxxxxxxxxxx
12733                                                              cadd.  */
12734                                                           return 2071;
12735                                                         }
12736                                                       else
12737                                                         {
12738                                                           /* 33222222222211111111110000000000
12739                                                              10987654321098765432109876543210
12740                                                              010001x1xx0xxxx111011xxxxxxxxxxx
12741                                                              sqcadd.  */
12742                                                           return 2179;
12743                                                         }
12744                                                     }
12745                                                 }
12746                                             }
12747                                           else
12748                                             {
12749                                               if (((word >> 22) & 0x1) == 0)
12750                                                 {
12751                                                   if (((word >> 23) & 0x1) == 0)
12752                                                     {
12753                                                       /* 33222222222211111111110000000000
12754                                                          10987654321098765432109876543210
12755                                                          110001x1000xxxxx110xxxxxxxxxxxxx
12756                                                          ldnt1w.  */
12757                                                       return 2113;
12758                                                     }
12759                                                   else
12760                                                     {
12761                                                       /* 33222222222211111111110000000000
12762                                                          10987654321098765432109876543210
12763                                                          110001x1100xxxxx110xxxxxxxxxxxxx
12764                                                          ldnt1d.  */
12765                                                       return 2106;
12766                                                     }
12767                                                 }
12768                                               else
12769                                                 {
12770                                                   if (((word >> 23) & 0x1) == 0)
12771                                                     {
12772                                                       /* 33222222222211111111110000000000
12773                                                          10987654321098765432109876543210
12774                                                          110001x1010xxxxx110xxxxxxxxxxxxx
12775                                                          ld1w.  */
12776                                                       return 1610;
12777                                                     }
12778                                                   else
12779                                                     {
12780                                                       /* 33222222222211111111110000000000
12781                                                          10987654321098765432109876543210
12782                                                          110001x1110xxxxx110xxxxxxxxxxxxx
12783                                                          ld1d.  */
12784                                                       return 1532;
12785                                                     }
12786                                                 }
12787                                             }
12788                                         }
12789                                       else
12790                                         {
12791                                           if (((word >> 23) & 0x1) == 0)
12792                                             {
12793                                               if (((word >> 22) & 0x1) == 0)
12794                                                 {
12795                                                   /* 33222222222211111111110000000000
12796                                                      10987654321098765432109876543210
12797                                                      x10001x1001xxxxx110xxxxxxxxxxxxx
12798                                                      ld1w.  */
12799                                                   return 1615;
12800                                                 }
12801                                               else
12802                                                 {
12803                                                   /* 33222222222211111111110000000000
12804                                                      10987654321098765432109876543210
12805                                                      x10001x1011xxxxx110xxxxxxxxxxxxx
12806                                                      ld1w.  */
12807                                                   return 1611;
12808                                                 }
12809                                             }
12810                                           else
12811                                             {
12812                                               if (((word >> 31) & 0x1) == 0)
12813                                                 {
12814                                                   /* 33222222222211111111110000000000
12815                                                      10987654321098765432109876543210
12816                                                      010001x11x1xxxxx110xxxxxxxxxxxxx
12817                                                      histcnt.  */
12818                                                   return 2102;
12819                                                 }
12820                                               else
12821                                                 {
12822                                                   if (((word >> 22) & 0x1) == 0)
12823                                                     {
12824                                                       /* 33222222222211111111110000000000
12825                                                          10987654321098765432109876543210
12826                                                          110001x1101xxxxx110xxxxxxxxxxxxx
12827                                                          ld1d.  */
12828                                                       return 1535;
12829                                                     }
12830                                                   else
12831                                                     {
12832                                                       /* 33222222222211111111110000000000
12833                                                          10987654321098765432109876543210
12834                                                          110001x1111xxxxx110xxxxxxxxxxxxx
12835                                                          ld1d.  */
12836                                                       return 1533;
12837                                                     }
12838                                                 }
12839                                             }
12840                                         }
12841                                     }
12842                                 }
12843                             }
12844                           else
12845                             {
12846                               if (((word >> 14) & 0x1) == 0)
12847                                 {
12848                                   if (((word >> 15) & 0x1) == 0)
12849                                     {
12850                                       if (((word >> 21) & 0x1) == 0)
12851                                         {
12852                                           if (((word >> 31) & 0x1) == 0)
12853                                             {
12854                                               if (((word >> 10) & 0x1) == 0)
12855                                                 {
12856                                                   if (((word >> 11) & 0x1) == 0)
12857                                                     {
12858                                                       /* 33222222222211111111110000000000
12859                                                          10987654321098765432109876543210
12860                                                          010001x1xx0xxxxx001x00xxxxxxxxxx
12861                                                          sabdlb.  */
12862                                                       return 2139;
12863                                                     }
12864                                                   else
12865                                                     {
12866                                                       /* 33222222222211111111110000000000
12867                                                          10987654321098765432109876543210
12868                                                          010001x1xx0xxxxx001x10xxxxxxxxxx
12869                                                          uabdlb.  */
12870                                                       return 2270;
12871                                                     }
12872                                                 }
12873                                               else
12874                                                 {
12875                                                   if (((word >> 11) & 0x1) == 0)
12876                                                     {
12877                                                       /* 33222222222211111111110000000000
12878                                                          10987654321098765432109876543210
12879                                                          010001x1xx0xxxxx001x01xxxxxxxxxx
12880                                                          sabdlt.  */
12881                                                       return 2140;
12882                                                     }
12883                                                   else
12884                                                     {
12885                                                       /* 33222222222211111111110000000000
12886                                                          10987654321098765432109876543210
12887                                                          010001x1xx0xxxxx001x11xxxxxxxxxx
12888                                                          uabdlt.  */
12889                                                       return 2271;
12890                                                     }
12891                                                 }
12892                                             }
12893                                           else
12894                                             {
12895                                               /* 33222222222211111111110000000000
12896                                                  10987654321098765432109876543210
12897                                                  110001x1xx0xxxxx001xxxxxxxxxxxxx
12898                                                  ldff1sw.  */
12899                                               return 1699;
12900                                             }
12901                                         }
12902                                       else
12903                                         {
12904                                           if (((word >> 31) & 0x1) == 0)
12905                                             {
12906                                               if (((word >> 10) & 0x1) == 0)
12907                                                 {
12908                                                   if (((word >> 11) & 0x1) == 0)
12909                                                     {
12910                                                       if (((word >> 12) & 0x1) == 0)
12911                                                         {
12912                                                           /* 33222222222211111111110000000000
12913                                                              10987654321098765432109876543210
12914                                                              010001x1xx1xxxxx001000xxxxxxxxxx
12915                                                              sqshrnb.  */
12916                                                           return 2230;
12917                                                         }
12918                                                       else
12919                                                         {
12920                                                           /* 33222222222211111111110000000000
12921                                                              10987654321098765432109876543210
12922                                                              010001x1xx1xxxxx001100xxxxxxxxxx
12923                                                              uqshrnb.  */
12924                                                           return 2309;
12925                                                         }
12926                                                     }
12927                                                   else
12928                                                     {
12929                                                       if (((word >> 12) & 0x1) == 0)
12930                                                         {
12931                                                           /* 33222222222211111111110000000000
12932                                                              10987654321098765432109876543210
12933                                                              010001x1xx1xxxxx001010xxxxxxxxxx
12934                                                              sqrshrnb.  */
12935                                                           return 2222;
12936                                                         }
12937                                                       else
12938                                                         {
12939                                                           /* 33222222222211111111110000000000
12940                                                              10987654321098765432109876543210
12941                                                              010001x1xx1xxxxx001110xxxxxxxxxx
12942                                                              uqrshrnb.  */
12943                                                           return 2304;
12944                                                         }
12945                                                     }
12946                                                 }
12947                                               else
12948                                                 {
12949                                                   if (((word >> 11) & 0x1) == 0)
12950                                                     {
12951                                                       if (((word >> 12) & 0x1) == 0)
12952                                                         {
12953                                                           /* 33222222222211111111110000000000
12954                                                              10987654321098765432109876543210
12955                                                              010001x1xx1xxxxx001001xxxxxxxxxx
12956                                                              sqshrnt.  */
12957                                                           return 2231;
12958                                                         }
12959                                                       else
12960                                                         {
12961                                                           /* 33222222222211111111110000000000
12962                                                              10987654321098765432109876543210
12963                                                              010001x1xx1xxxxx001101xxxxxxxxxx
12964                                                              uqshrnt.  */
12965                                                           return 2310;
12966                                                         }
12967                                                     }
12968                                                   else
12969                                                     {
12970                                                       if (((word >> 12) & 0x1) == 0)
12971                                                         {
12972                                                           /* 33222222222211111111110000000000
12973                                                              10987654321098765432109876543210
12974                                                              010001x1xx1xxxxx001011xxxxxxxxxx
12975                                                              sqrshrnt.  */
12976                                                           return 2223;
12977                                                         }
12978                                                       else
12979                                                         {
12980                                                           /* 33222222222211111111110000000000
12981                                                              10987654321098765432109876543210
12982                                                              010001x1xx1xxxxx001111xxxxxxxxxx
12983                                                              uqrshrnt.  */
12984                                                           return 2305;
12985                                                         }
12986                                                     }
12987                                                 }
12988                                             }
12989                                           else
12990                                             {
12991                                               /* 33222222222211111111110000000000
12992                                                  10987654321098765432109876543210
12993                                                  110001x1xx1xxxxx001xxxxxxxxxxxxx
12994                                                  ldff1sw.  */
12995                                               return 1700;
12996                                             }
12997                                         }
12998                                     }
12999                                   else
13000                                     {
13001                                       if (((word >> 21) & 0x1) == 0)
13002                                         {
13003                                           if (((word >> 31) & 0x1) == 0)
13004                                             {
13005                                               if (((word >> 10) & 0x1) == 0)
13006                                                 {
13007                                                   if (((word >> 11) & 0x1) == 0)
13008                                                     {
13009                                                       if (((word >> 12) & 0x1) == 0)
13010                                                         {
13011                                                           /* 33222222222211111111110000000000
13012                                                              10987654321098765432109876543210
13013                                                              010001x1xx0xxxxx101000xxxxxxxxxx
13014                                                              sshllb.  */
13015                                                           return 2246;
13016                                                         }
13017                                                       else
13018                                                         {
13019                                                           /* 33222222222211111111110000000000
13020                                                              10987654321098765432109876543210
13021                                                              010001x1xx0xxxxx101100xxxxxxxxxx
13022                                                              bext.  */
13023                                                           return 2351;
13024                                                         }
13025                                                     }
13026                                                   else
13027                                                     {
13028                                                       if (((word >> 12) & 0x1) == 0)
13029                                                         {
13030                                                           /* 33222222222211111111110000000000
13031                                                              10987654321098765432109876543210
13032                                                              010001x1xx0xxxxx101010xxxxxxxxxx
13033                                                              ushllb.  */
13034                                                           return 2322;
13035                                                         }
13036                                                       else
13037                                                         {
13038                                                           /* 33222222222211111111110000000000
13039                                                              10987654321098765432109876543210
13040                                                              010001x1xx0xxxxx101110xxxxxxxxxx
13041                                                              bgrp.  */
13042                                                           return 2352;
13043                                                         }
13044                                                     }
13045                                                 }
13046                                               else
13047                                                 {
13048                                                   if (((word >> 11) & 0x1) == 0)
13049                                                     {
13050                                                       if (((word >> 12) & 0x1) == 0)
13051                                                         {
13052                                                           /* 33222222222211111111110000000000
13053                                                              10987654321098765432109876543210
13054                                                              010001x1xx0xxxxx101001xxxxxxxxxx
13055                                                              sshllt.  */
13056                                                           return 2247;
13057                                                         }
13058                                                       else
13059                                                         {
13060                                                           /* 33222222222211111111110000000000
13061                                                              10987654321098765432109876543210
13062                                                              010001x1xx0xxxxx101101xxxxxxxxxx
13063                                                              bdep.  */
13064                                                           return 2350;
13065                                                         }
13066                                                     }
13067                                                   else
13068                                                     {
13069                                                       /* 33222222222211111111110000000000
13070                                                          10987654321098765432109876543210
13071                                                          010001x1xx0xxxxx101x11xxxxxxxxxx
13072                                                          ushllt.  */
13073                                                       return 2323;
13074                                                     }
13075                                                 }
13076                                             }
13077                                           else
13078                                             {
13079                                               /* 33222222222211111111110000000000
13080                                                  10987654321098765432109876543210
13081                                                  110001x1xx0xxxxx101xxxxxxxxxxxxx
13082                                                  ldff1sw.  */
13083                                               return 1701;
13084                                             }
13085                                         }
13086                                       else
13087                                         {
13088                                           if (((word >> 22) & 0x1) == 0)
13089                                             {
13090                                               if (((word >> 31) & 0x1) == 0)
13091                                                 {
13092                                                   /* 33222222222211111111110000000000
13093                                                      10987654321098765432109876543210
13094                                                      010001x1x01xxxxx101xxxxxxxxxxxxx
13095                                                      histseg.  */
13096                                                   return 2103;
13097                                                 }
13098                                               else
13099                                                 {
13100                                                   /* 33222222222211111111110000000000
13101                                                      10987654321098765432109876543210
13102                                                      110001x1x01xxxxx101xxxxxxxxxxxxx
13103                                                      ldff1sw.  */
13104                                                   return 1703;
13105                                                 }
13106                                             }
13107                                           else
13108                                             {
13109                                               /* 33222222222211111111110000000000
13110                                                  10987654321098765432109876543210
13111                                                  x10001x1x11xxxxx101xxxxxxxxxxxxx
13112                                                  ldff1sw.  */
13113                                               return 1702;
13114                                             }
13115                                         }
13116                                     }
13117                                 }
13118                               else
13119                                 {
13120                                   if (((word >> 15) & 0x1) == 0)
13121                                     {
13122                                       if (((word >> 21) & 0x1) == 0)
13123                                         {
13124                                           if (((word >> 31) & 0x1) == 0)
13125                                             {
13126                                               if (((word >> 10) & 0x1) == 0)
13127                                                 {
13128                                                   if (((word >> 11) & 0x1) == 0)
13129                                                     {
13130                                                       if (((word >> 12) & 0x1) == 0)
13131                                                         {
13132                                                           /* 33222222222211111111110000000000
13133                                                              10987654321098765432109876543210
13134                                                              010001x1xx0xxxxx011000xxxxxxxxxx
13135                                                              sqdmullb.  */
13136                                                           return 2200;
13137                                                         }
13138                                                       else
13139                                                         {
13140                                                           /* 33222222222211111111110000000000
13141                                                              10987654321098765432109876543210
13142                                                              010001x1xx0xxxxx011100xxxxxxxxxx
13143                                                              smullb.  */
13144                                                           return 2172;
13145                                                         }
13146                                                     }
13147                                                   else
13148                                                     {
13149                                                       if (((word >> 12) & 0x1) == 0)
13150                                                         {
13151                                                           if (((word >> 22) & 0x1) == 0)
13152                                                             {
13153                                                               /* 33222222222211111111110000000000
13154                                                                  10987654321098765432109876543210
13155                                                                  010001x1x00xxxxx011010xxxxxxxxxx
13156                                                                  pmullb.  */
13157                                                               return 2347;
13158                                                             }
13159                                                           else
13160                                                             {
13161                                                               /* 33222222222211111111110000000000
13162                                                                  10987654321098765432109876543210
13163                                                                  010001x1x10xxxxx011010xxxxxxxxxx
13164                                                                  pmullb.  */
13165                                                               return 2128;
13166                                                             }
13167                                                         }
13168                                                       else
13169                                                         {
13170                                                           /* 33222222222211111111110000000000
13171                                                              10987654321098765432109876543210
13172                                                              010001x1xx0xxxxx011110xxxxxxxxxx
13173                                                              umullb.  */
13174                                                           return 2297;
13175                                                         }
13176                                                     }
13177                                                 }
13178                                               else
13179                                                 {
13180                                                   if (((word >> 11) & 0x1) == 0)
13181                                                     {
13182                                                       if (((word >> 12) & 0x1) == 0)
13183                                                         {
13184                                                           /* 33222222222211111111110000000000
13185                                                              10987654321098765432109876543210
13186                                                              010001x1xx0xxxxx011001xxxxxxxxxx
13187                                                              sqdmullt.  */
13188                                                           return 2203;
13189                                                         }
13190                                                       else
13191                                                         {
13192                                                           /* 33222222222211111111110000000000
13193                                                              10987654321098765432109876543210
13194                                                              010001x1xx0xxxxx011101xxxxxxxxxx
13195                                                              smullt.  */
13196                                                           return 2175;
13197                                                         }
13198                                                     }
13199                                                   else
13200                                                     {
13201                                                       if (((word >> 12) & 0x1) == 0)
13202                                                         {
13203                                                           if (((word >> 22) & 0x1) == 0)
13204                                                             {
13205                                                               /* 33222222222211111111110000000000
13206                                                                  10987654321098765432109876543210
13207                                                                  010001x1x00xxxxx011011xxxxxxxxxx
13208                                                                  pmullt.  */
13209                                                               return 2348;
13210                                                             }
13211                                                           else
13212                                                             {
13213                                                               /* 33222222222211111111110000000000
13214                                                                  10987654321098765432109876543210
13215                                                                  010001x1x10xxxxx011011xxxxxxxxxx
13216                                                                  pmullt.  */
13217                                                               return 2129;
13218                                                             }
13219                                                         }
13220                                                       else
13221                                                         {
13222                                                           /* 33222222222211111111110000000000
13223                                                              10987654321098765432109876543210
13224                                                              010001x1xx0xxxxx011111xxxxxxxxxx
13225                                                              umullt.  */
13226                                                           return 2300;
13227                                                         }
13228                                                     }
13229                                                 }
13230                                             }
13231                                           else
13232                                             {
13233                                               if (((word >> 23) & 0x1) == 0)
13234                                                 {
13235                                                   /* 33222222222211111111110000000000
13236                                                      10987654321098765432109876543210
13237                                                      110001x10x0xxxxx011xxxxxxxxxxxxx
13238                                                      ldff1w.  */
13239                                                   return 1710;
13240                                                 }
13241                                               else
13242                                                 {
13243                                                   /* 33222222222211111111110000000000
13244                                                      10987654321098765432109876543210
13245                                                      110001x11x0xxxxx011xxxxxxxxxxxxx
13246                                                      ldff1d.  */
13247                                                   return 1655;
13248                                                 }
13249                                             }
13250                                         }
13251                                       else
13252                                         {
13253                                           if (((word >> 31) & 0x1) == 0)
13254                                             {
13255                                               if (((word >> 10) & 0x1) == 0)
13256                                                 {
13257                                                   if (((word >> 11) & 0x1) == 0)
13258                                                     {
13259                                                       if (((word >> 12) & 0x1) == 0)
13260                                                         {
13261                                                           /* 33222222222211111111110000000000
13262                                                              10987654321098765432109876543210
13263                                                              010001x1xx1xxxxx011000xxxxxxxxxx
13264                                                              addhnb.  */
13265                                                           return 2064;
13266                                                         }
13267                                                       else
13268                                                         {
13269                                                           /* 33222222222211111111110000000000
13270                                                              10987654321098765432109876543210
13271                                                              010001x1xx1xxxxx011100xxxxxxxxxx
13272                                                              subhnb.  */
13273                                                           return 2262;
13274                                                         }
13275                                                     }
13276                                                   else
13277                                                     {
13278                                                       if (((word >> 12) & 0x1) == 0)
13279                                                         {
13280                                                           /* 33222222222211111111110000000000
13281                                                              10987654321098765432109876543210
13282                                                              010001x1xx1xxxxx011010xxxxxxxxxx
13283                                                              raddhnb.  */
13284                                                           return 2130;
13285                                                         }
13286                                                       else
13287                                                         {
13288                                                           /* 33222222222211111111110000000000
13289                                                              10987654321098765432109876543210
13290                                                              010001x1xx1xxxxx011110xxxxxxxxxx
13291                                                              rsubhnb.  */
13292                                                           return 2134;
13293                                                         }
13294                                                     }
13295                                                 }
13296                                               else
13297                                                 {
13298                                                   if (((word >> 11) & 0x1) == 0)
13299                                                     {
13300                                                       if (((word >> 12) & 0x1) == 0)
13301                                                         {
13302                                                           /* 33222222222211111111110000000000
13303                                                              10987654321098765432109876543210
13304                                                              010001x1xx1xxxxx011001xxxxxxxxxx
13305                                                              addhnt.  */
13306                                                           return 2065;
13307                                                         }
13308                                                       else
13309                                                         {
13310                                                           /* 33222222222211111111110000000000
13311                                                              10987654321098765432109876543210
13312                                                              010001x1xx1xxxxx011101xxxxxxxxxx
13313                                                              subhnt.  */
13314                                                           return 2263;
13315                                                         }
13316                                                     }
13317                                                   else
13318                                                     {
13319                                                       if (((word >> 12) & 0x1) == 0)
13320                                                         {
13321                                                           /* 33222222222211111111110000000000
13322                                                              10987654321098765432109876543210
13323                                                              010001x1xx1xxxxx011011xxxxxxxxxx
13324                                                              raddhnt.  */
13325                                                           return 2131;
13326                                                         }
13327                                                       else
13328                                                         {
13329                                                           /* 33222222222211111111110000000000
13330                                                              10987654321098765432109876543210
13331                                                              010001x1xx1xxxxx011111xxxxxxxxxx
13332                                                              rsubhnt.  */
13333                                                           return 2135;
13334                                                         }
13335                                                     }
13336                                                 }
13337                                             }
13338                                           else
13339                                             {
13340                                               if (((word >> 23) & 0x1) == 0)
13341                                                 {
13342                                                   /* 33222222222211111111110000000000
13343                                                      10987654321098765432109876543210
13344                                                      110001x10x1xxxxx011xxxxxxxxxxxxx
13345                                                      ldff1w.  */
13346                                                   return 1711;
13347                                                 }
13348                                               else
13349                                                 {
13350                                                   /* 33222222222211111111110000000000
13351                                                      10987654321098765432109876543210
13352                                                      110001x11x1xxxxx011xxxxxxxxxxxxx
13353                                                      ldff1d.  */
13354                                                   return 1656;
13355                                                 }
13356                                             }
13357                                         }
13358                                     }
13359                                   else
13360                                     {
13361                                       if (((word >> 21) & 0x1) == 0)
13362                                         {
13363                                           if (((word >> 31) & 0x1) == 0)
13364                                             {
13365                                               if (((word >> 10) & 0x1) == 0)
13366                                                 {
13367                                                   if (((word >> 11) & 0x1) == 0)
13368                                                     {
13369                                                       if (((word >> 12) & 0x1) == 0)
13370                                                         {
13371                                                           /* 33222222222211111111110000000000
13372                                                              10987654321098765432109876543210
13373                                                              010001x1xx0xxxxx111000xxxxxxxxxx
13374                                                              ssra.  */
13375                                                           return 2248;
13376                                                         }
13377                                                       else
13378                                                         {
13379                                                           /* 33222222222211111111110000000000
13380                                                              10987654321098765432109876543210
13381                                                              010001x1xx0xxxxx111100xxxxxxxxxx
13382                                                              sri.  */
13383                                                           return 2241;
13384                                                         }
13385                                                     }
13386                                                   else
13387                                                     {
13388                                                       if (((word >> 12) & 0x1) == 0)
13389                                                         {
13390                                                           /* 33222222222211111111110000000000
13391                                                              10987654321098765432109876543210
13392                                                              010001x1xx0xxxxx111010xxxxxxxxxx
13393                                                              srsra.  */
13394                                                           return 2245;
13395                                                         }
13396                                                       else
13397                                                         {
13398                                                           /* 33222222222211111111110000000000
13399                                                              10987654321098765432109876543210
13400                                                              010001x1xx0xxxxx111110xxxxxxxxxx
13401                                                              saba.  */
13402                                                           return 2136;
13403                                                         }
13404                                                     }
13405                                                 }
13406                                               else
13407                                                 {
13408                                                   if (((word >> 11) & 0x1) == 0)
13409                                                     {
13410                                                       if (((word >> 12) & 0x1) == 0)
13411                                                         {
13412                                                           /* 33222222222211111111110000000000
13413                                                              10987654321098765432109876543210
13414                                                              010001x1xx0xxxxx111001xxxxxxxxxx
13415                                                              usra.  */
13416                                                           return 2325;
13417                                                         }
13418                                                       else
13419                                                         {
13420                                                           /* 33222222222211111111110000000000
13421                                                              10987654321098765432109876543210
13422                                                              010001x1xx0xxxxx111101xxxxxxxxxx
13423                                                              sli.  */
13424                                                           return 2154;
13425                                                         }
13426                                                     }
13427                                                   else
13428                                                     {
13429                                                       if (((word >> 12) & 0x1) == 0)
13430                                                         {
13431                                                           /* 33222222222211111111110000000000
13432                                                              10987654321098765432109876543210
13433                                                              010001x1xx0xxxxx111011xxxxxxxxxx
13434                                                              ursra.  */
13435                                                           return 2321;
13436                                                         }
13437                                                       else
13438                                                         {
13439                                                           /* 33222222222211111111110000000000
13440                                                              10987654321098765432109876543210
13441                                                              010001x1xx0xxxxx111111xxxxxxxxxx
13442                                                              uaba.  */
13443                                                           return 2267;
13444                                                         }
13445                                                     }
13446                                                 }
13447                                             }
13448                                           else
13449                                             {
13450                                               if (((word >> 22) & 0x1) == 0)
13451                                                 {
13452                                                   if (((word >> 23) & 0x1) == 0)
13453                                                     {
13454                                                       /* 33222222222211111111110000000000
13455                                                          10987654321098765432109876543210
13456                                                          110001x1000xxxxx111xxxxxxxxxxxxx
13457                                                          prfw.  */
13458                                                       return 1806;
13459                                                     }
13460                                                   else
13461                                                     {
13462                                                       /* 33222222222211111111110000000000
13463                                                          10987654321098765432109876543210
13464                                                          110001x1100xxxxx111xxxxxxxxxxxxx
13465                                                          prfd.  */
13466                                                       return 1792;
13467                                                     }
13468                                                 }
13469                                               else
13470                                                 {
13471                                                   if (((word >> 23) & 0x1) == 0)
13472                                                     {
13473                                                       /* 33222222222211111111110000000000
13474                                                          10987654321098765432109876543210
13475                                                          110001x1010xxxxx111xxxxxxxxxxxxx
13476                                                          ldff1w.  */
13477                                                       return 1712;
13478                                                     }
13479                                                   else
13480                                                     {
13481                                                       /* 33222222222211111111110000000000
13482                                                          10987654321098765432109876543210
13483                                                          110001x1110xxxxx111xxxxxxxxxxxxx
13484                                                          ldff1d.  */
13485                                                       return 1657;
13486                                                     }
13487                                                 }
13488                                             }
13489                                         }
13490                                       else
13491                                         {
13492                                           if (((word >> 22) & 0x1) == 0)
13493                                             {
13494                                               if (((word >> 23) & 0x1) == 0)
13495                                                 {
13496                                                   if (((word >> 31) & 0x1) == 0)
13497                                                     {
13498                                                       if (((word >> 10) & 0x1) == 0)
13499                                                         {
13500                                                           if (((word >> 12) & 0x1) == 0)
13501                                                             {
13502                                                               if (((word >> 16) & 0x1) == 0)
13503                                                                 {
13504                                                                   if (((word >> 17) & 0x1) == 0)
13505                                                                     {
13506                                                                       /* 33222222222211111111110000000000
13507                                                                          10987654321098765432109876543210
13508                                                                          010001x1001xxx001110x0xxxxxxxxxx
13509                                                                          aesmc.  */
13510                                                                       return 2346;
13511                                                                     }
13512                                                                   else
13513                                                                     {
13514                                                                       /* 33222222222211111111110000000000
13515                                                                          10987654321098765432109876543210
13516                                                                          010001x1001xxx101110x0xxxxxxxxxx
13517                                                                          aese.  */
13518                                                                       return 2344;
13519                                                                     }
13520                                                                 }
13521                                                               else
13522                                                                 {
13523                                                                   /* 33222222222211111111110000000000
13524                                                                      10987654321098765432109876543210
13525                                                                      010001x1001xxxx11110x0xxxxxxxxxx
13526                                                                      sm4e.  */
13527                                                                   return 2341;
13528                                                                 }
13529                                                             }
13530                                                           else
13531                                                             {
13532                                                               /* 33222222222211111111110000000000
13533                                                                  10987654321098765432109876543210
13534                                                                  010001x1001xxxxx1111x0xxxxxxxxxx
13535                                                                  sm4ekey.  */
13536                                                               return 2342;
13537                                                             }
13538                                                         }
13539                                                       else
13540                                                         {
13541                                                           if (((word >> 12) & 0x1) == 0)
13542                                                             {
13543                                                               if (((word >> 17) & 0x1) == 0)
13544                                                                 {
13545                                                                   /* 33222222222211111111110000000000
13546                                                                      10987654321098765432109876543210
13547                                                                      010001x1001xxx0x1110x1xxxxxxxxxx
13548                                                                      aesimc.  */
13549                                                                   return 2345;
13550                                                                 }
13551                                                               else
13552                                                                 {
13553                                                                   /* 33222222222211111111110000000000
13554                                                                      10987654321098765432109876543210
13555                                                                      010001x1001xxx1x1110x1xxxxxxxxxx
13556                                                                      aesd.  */
13557                                                                   return 2343;
13558                                                                 }
13559                                                             }
13560                                                           else
13561                                                             {
13562                                                               /* 33222222222211111111110000000000
13563                                                                  10987654321098765432109876543210
13564                                                                  010001x1001xxxxx1111x1xxxxxxxxxx
13565                                                                  rax1.  */
13566                                                               return 2349;
13567                                                             }
13568                                                         }
13569                                                     }
13570                                                   else
13571                                                     {
13572                                                       /* 33222222222211111111110000000000
13573                                                          10987654321098765432109876543210
13574                                                          110001x1001xxxxx111xxxxxxxxxxxxx
13575                                                          ldff1w.  */
13576                                                       return 1715;
13577                                                     }
13578                                                 }
13579                                               else
13580                                                 {
13581                                                   /* 33222222222211111111110000000000
13582                                                      10987654321098765432109876543210
13583                                                      x10001x1101xxxxx111xxxxxxxxxxxxx
13584                                                      ldff1d.  */
13585                                                   return 1659;
13586                                                 }
13587                                             }
13588                                           else
13589                                             {
13590                                               if (((word >> 23) & 0x1) == 0)
13591                                                 {
13592                                                   /* 33222222222211111111110000000000
13593                                                      10987654321098765432109876543210
13594                                                      x10001x1011xxxxx111xxxxxxxxxxxxx
13595                                                      ldff1w.  */
13596                                                   return 1713;
13597                                                 }
13598                                               else
13599                                                 {
13600                                                   /* 33222222222211111111110000000000
13601                                                      10987654321098765432109876543210
13602                                                      x10001x1111xxxxx111xxxxxxxxxxxxx
13603                                                      ldff1d.  */
13604                                                   return 1658;
13605                                                 }
13606                                             }
13607                                         }
13608                                     }
13609                                 }
13610                             }
13611                         }
13612                     }
13613                   else
13614                     {
13615                       if (((word >> 15) & 0x1) == 0)
13616                         {
13617                           if (((word >> 14) & 0x1) == 0)
13618                             {
13619                               if (((word >> 13) & 0x1) == 0)
13620                                 {
13621                                   if (((word >> 30) & 0x1) == 0)
13622                                     {
13623                                       if (((word >> 21) & 0x1) == 0)
13624                                         {
13625                                           if (((word >> 31) & 0x1) == 0)
13626                                             {
13627                                               if (((word >> 4) & 0x1) == 0)
13628                                                 {
13629                                                   /* 33222222222211111111110000000000
13630                                                      10987654321098765432109876543210
13631                                                      001001x1xx0xxxxx000xxxxxxxx0xxxx
13632                                                      cmpge.  */
13633                                                   return 1338;
13634                                                 }
13635                                               else
13636                                                 {
13637                                                   /* 33222222222211111111110000000000
13638                                                      10987654321098765432109876543210
13639                                                      001001x1xx0xxxxx000xxxxxxxx1xxxx
13640                                                      cmpgt.  */
13641                                                   return 1341;
13642                                                 }
13643                                             }
13644                                           else
13645                                             {
13646                                               if (((word >> 23) & 0x1) == 0)
13647                                                 {
13648                                                   /* 33222222222211111111110000000000
13649                                                      10987654321098765432109876543210
13650                                                      101001x10x0xxxxx000xxxxxxxxxxxxx
13651                                                      ld1rqw.  */
13652                                                   return 1565;
13653                                                 }
13654                                               else
13655                                                 {
13656                                                   /* 33222222222211111111110000000000
13657                                                      10987654321098765432109876543210
13658                                                      101001x11x0xxxxx000xxxxxxxxxxxxx
13659                                                      ld1rqd.  */
13660                                                   return 1561;
13661                                                 }
13662                                             }
13663                                         }
13664                                       else
13665                                         {
13666                                           if (((word >> 31) & 0x1) == 0)
13667                                             {
13668                                               if (((word >> 4) & 0x1) == 0)
13669                                                 {
13670                                                   if (((word >> 10) & 0x1) == 0)
13671                                                     {
13672                                                       if (((word >> 11) & 0x1) == 0)
13673                                                         {
13674                                                           if (((word >> 12) & 0x1) == 0)
13675                                                             {
13676                                                               /* 33222222222211111111110000000000
13677                                                                  10987654321098765432109876543210
13678                                                                  001001x1xx1xxxxx000000xxxxx0xxxx
13679                                                                  whilege.  */
13680                                                               return 2330;
13681                                                             }
13682                                                           else
13683                                                             {
13684                                                               /* 33222222222211111111110000000000
13685                                                                  10987654321098765432109876543210
13686                                                                  001001x1xx1xxxxx000100xxxxx0xxxx
13687                                                                  whilege.  */
13688                                                               return 2331;
13689                                                             }
13690                                                         }
13691                                                       else
13692                                                         {
13693                                                           if (((word >> 12) & 0x1) == 0)
13694                                                             {
13695                                                               /* 33222222222211111111110000000000
13696                                                                  10987654321098765432109876543210
13697                                                                  001001x1xx1xxxxx000010xxxxx0xxxx
13698                                                                  whilehs.  */
13699                                                               return 2336;
13700                                                             }
13701                                                           else
13702                                                             {
13703                                                               /* 33222222222211111111110000000000
13704                                                                  10987654321098765432109876543210
13705                                                                  001001x1xx1xxxxx000110xxxxx0xxxx
13706                                                                  whilehs.  */
13707                                                               return 2337;
13708                                                             }
13709                                                         }
13710                                                     }
13711                                                   else
13712                                                     {
13713                                                       if (((word >> 11) & 0x1) == 0)
13714                                                         {
13715                                                           if (((word >> 12) & 0x1) == 0)
13716                                                             {
13717                                                               /* 33222222222211111111110000000000
13718                                                                  10987654321098765432109876543210
13719                                                                  001001x1xx1xxxxx000001xxxxx0xxxx
13720                                                                  whilelt.  */
13721                                                               return 2042;
13722                                                             }
13723                                                           else
13724                                                             {
13725                                                               /* 33222222222211111111110000000000
13726                                                                  10987654321098765432109876543210
13727                                                                  001001x1xx1xxxxx000101xxxxx0xxxx
13728                                                                  whilelt.  */
13729                                                               return 2043;
13730                                                             }
13731                                                         }
13732                                                       else
13733                                                         {
13734                                                           if (((word >> 12) & 0x1) == 0)
13735                                                             {
13736                                                               /* 33222222222211111111110000000000
13737                                                                  10987654321098765432109876543210
13738                                                                  001001x1xx1xxxxx000011xxxxx0xxxx
13739                                                                  whilelo.  */
13740                                                               return 2038;
13741                                                             }
13742                                                           else
13743                                                             {
13744                                                               /* 33222222222211111111110000000000
13745                                                                  10987654321098765432109876543210
13746                                                                  001001x1xx1xxxxx000111xxxxx0xxxx
13747                                                                  whilelo.  */
13748                                                               return 2039;
13749                                                             }
13750                                                         }
13751                                                     }
13752                                                 }
13753                                               else
13754                                                 {
13755                                                   if (((word >> 10) & 0x1) == 0)
13756                                                     {
13757                                                       if (((word >> 11) & 0x1) == 0)
13758                                                         {
13759                                                           if (((word >> 12) & 0x1) == 0)
13760                                                             {
13761                                                               /* 33222222222211111111110000000000
13762                                                                  10987654321098765432109876543210
13763                                                                  001001x1xx1xxxxx000000xxxxx1xxxx
13764                                                                  whilegt.  */
13765                                                               return 2332;
13766                                                             }
13767                                                           else
13768                                                             {
13769                                                               /* 33222222222211111111110000000000
13770                                                                  10987654321098765432109876543210
13771                                                                  001001x1xx1xxxxx000100xxxxx1xxxx
13772                                                                  whilegt.  */
13773                                                               return 2333;
13774                                                             }
13775                                                         }
13776                                                       else
13777                                                         {
13778                                                           if (((word >> 12) & 0x1) == 0)
13779                                                             {
13780                                                               /* 33222222222211111111110000000000
13781                                                                  10987654321098765432109876543210
13782                                                                  001001x1xx1xxxxx000010xxxxx1xxxx
13783                                                                  whilehi.  */
13784                                                               return 2334;
13785                                                             }
13786                                                           else
13787                                                             {
13788                                                               /* 33222222222211111111110000000000
13789                                                                  10987654321098765432109876543210
13790                                                                  001001x1xx1xxxxx000110xxxxx1xxxx
13791                                                                  whilehi.  */
13792                                                               return 2335;
13793                                                             }
13794                                                         }
13795                                                     }
13796                                                   else
13797                                                     {
13798                                                       if (((word >> 11) & 0x1) == 0)
13799                                                         {
13800                                                           if (((word >> 12) & 0x1) == 0)
13801                                                             {
13802                                                               /* 33222222222211111111110000000000
13803                                                                  10987654321098765432109876543210
13804                                                                  001001x1xx1xxxxx000001xxxxx1xxxx
13805                                                                  whilele.  */
13806                                                               return 2036;
13807                                                             }
13808                                                           else
13809                                                             {
13810                                                               /* 33222222222211111111110000000000
13811                                                                  10987654321098765432109876543210
13812                                                                  001001x1xx1xxxxx000101xxxxx1xxxx
13813                                                                  whilele.  */
13814                                                               return 2037;
13815                                                             }
13816                                                         }
13817                                                       else
13818                                                         {
13819                                                           if (((word >> 12) & 0x1) == 0)
13820                                                             {
13821                                                               /* 33222222222211111111110000000000
13822                                                                  10987654321098765432109876543210
13823                                                                  001001x1xx1xxxxx000011xxxxx1xxxx
13824                                                                  whilels.  */
13825                                                               return 2040;
13826                                                             }
13827                                                           else
13828                                                             {
13829                                                               /* 33222222222211111111110000000000
13830                                                                  10987654321098765432109876543210
13831                                                                  001001x1xx1xxxxx000111xxxxx1xxxx
13832                                                                  whilels.  */
13833                                                               return 2041;
13834                                                             }
13835                                                         }
13836                                                     }
13837                                                 }
13838                                             }
13839                                           else
13840                                             {
13841                                               if (((word >> 23) & 0x1) == 0)
13842                                                 {
13843                                                   /* 33222222222211111111110000000000
13844                                                      10987654321098765432109876543210
13845                                                      101001x10x1xxxxx000xxxxxxxxxxxxx
13846                                                      ld1row.  */
13847                                                   return 2478;
13848                                                 }
13849                                               else
13850                                                 {
13851                                                   /* 33222222222211111111110000000000
13852                                                      10987654321098765432109876543210
13853                                                      101001x11x1xxxxx000xxxxxxxxxxxxx
13854                                                      ld1rod.  */
13855                                                   return 2479;
13856                                                 }
13857                                             }
13858                                         }
13859                                     }
13860                                   else
13861                                     {
13862                                       if (((word >> 31) & 0x1) == 0)
13863                                         {
13864                                           if (((word >> 21) & 0x1) == 0)
13865                                             {
13866                                               if (((word >> 10) & 0x1) == 0)
13867                                                 {
13868                                                   if (((word >> 11) & 0x1) == 0)
13869                                                     {
13870                                                       /* 33222222222211111111110000000000
13871                                                          10987654321098765432109876543210
13872                                                          011001x1xx0xxxxx000x00xxxxxxxxxx
13873                                                          fadd.  */
13874                                                       return 1396;
13875                                                     }
13876                                                   else
13877                                                     {
13878                                                       if (((word >> 12) & 0x1) == 0)
13879                                                         {
13880                                                           /* 33222222222211111111110000000000
13881                                                              10987654321098765432109876543210
13882                                                              011001x1xx0xxxxx000010xxxxxxxxxx
13883                                                              fmul.  */
13884                                                           return 1463;
13885                                                         }
13886                                                       else
13887                                                         {
13888                                                           /* 33222222222211111111110000000000
13889                                                              10987654321098765432109876543210
13890                                                              011001x1xx0xxxxx000110xxxxxxxxxx
13891                                                              frecps.  */
13892                                                           return 1476;
13893                                                         }
13894                                                     }
13895                                                 }
13896                                               else
13897                                                 {
13898                                                   if (((word >> 11) & 0x1) == 0)
13899                                                     {
13900                                                       /* 33222222222211111111110000000000
13901                                                          10987654321098765432109876543210
13902                                                          011001x1xx0xxxxx000x01xxxxxxxxxx
13903                                                          fsub.  */
13904                                                       return 1489;
13905                                                     }
13906                                                   else
13907                                                     {
13908                                                       if (((word >> 12) & 0x1) == 0)
13909                                                         {
13910                                                           /* 33222222222211111111110000000000
13911                                                              10987654321098765432109876543210
13912                                                              011001x1xx0xxxxx000011xxxxxxxxxx
13913                                                              ftsmul.  */
13914                                                           return 1495;
13915                                                         }
13916                                                       else
13917                                                         {
13918                                                           /* 33222222222211111111110000000000
13919                                                              10987654321098765432109876543210
13920                                                              011001x1xx0xxxxx000111xxxxxxxxxx
13921                                                              frsqrts.  */
13922                                                           return 1486;
13923                                                         }
13924                                                     }
13925                                                 }
13926                                             }
13927                                           else
13928                                             {
13929                                               /* 33222222222211111111110000000000
13930                                                  10987654321098765432109876543210
13931                                                  011001x1xx1xxxxx000xxxxxxxxxxxxx
13932                                                  fmla.  */
13933                                               return 1454;
13934                                             }
13935                                         }
13936                                       else
13937                                         {
13938                                           /* 33222222222211111111110000000000
13939                                              10987654321098765432109876543210
13940                                              111001x1xxxxxxxx000xxxxxxxxxxxxx
13941                                              str.  */
13942                                           return 1957;
13943                                         }
13944                                     }
13945                                 }
13946                               else
13947                                 {
13948                                   if (((word >> 21) & 0x1) == 0)
13949                                     {
13950                                       if (((word >> 30) & 0x1) == 0)
13951                                         {
13952                                           if (((word >> 31) & 0x1) == 0)
13953                                             {
13954                                               if (((word >> 4) & 0x1) == 0)
13955                                                 {
13956                                                   /* 33222222222211111111110000000000
13957                                                      10987654321098765432109876543210
13958                                                      001001x1xx0xxxxx001xxxxxxxx0xxxx
13959                                                      cmplt.  */
13960                                                   return 1355;
13961                                                 }
13962                                               else
13963                                                 {
13964                                                   /* 33222222222211111111110000000000
13965                                                      10987654321098765432109876543210
13966                                                      001001x1xx0xxxxx001xxxxxxxx1xxxx
13967                                                      cmple.  */
13968                                                   return 1349;
13969                                                 }
13970                                             }
13971                                           else
13972                                             {
13973                                               if (((word >> 23) & 0x1) == 0)
13974                                                 {
13975                                                   /* 33222222222211111111110000000000
13976                                                      10987654321098765432109876543210
13977                                                      101001x10x0xxxxx001xxxxxxxxxxxxx
13978                                                      ld1rqw.  */
13979                                                   return 1564;
13980                                                 }
13981                                               else
13982                                                 {
13983                                                   /* 33222222222211111111110000000000
13984                                                      10987654321098765432109876543210
13985                                                      101001x11x0xxxxx001xxxxxxxxxxxxx
13986                                                      ld1rqd.  */
13987                                                   return 1560;
13988                                                 }
13989                                             }
13990                                         }
13991                                       else
13992                                         {
13993                                           if (((word >> 31) & 0x1) == 0)
13994                                             {
13995                                               if (((word >> 16) & 0x1) == 0)
13996                                                 {
13997                                                   if (((word >> 17) & 0x1) == 0)
13998                                                     {
13999                                                       if (((word >> 18) & 0x1) == 0)
14000                                                         {
14001                                                           if (((word >> 19) & 0x1) == 0)
14002                                                             {
14003                                                               if (((word >> 20) & 0x1) == 0)
14004                                                                 {
14005                                                                   /* 33222222222211111111110000000000
14006                                                                      10987654321098765432109876543210
14007                                                                      011001x1xx000000001xxxxxxxxxxxxx
14008                                                                      faddv.  */
14009                                                                   return 1400;
14010                                                                 }
14011                                                               else
14012                                                                 {
14013                                                                   if (((word >> 4) & 0x1) == 0)
14014                                                                     {
14015                                                                       /* 33222222222211111111110000000000
14016                                                                          10987654321098765432109876543210
14017                                                                          011001x1xx010000001xxxxxxxx0xxxx
14018                                                                          fcmge.  */
14019                                                                       return 1407;
14020                                                                     }
14021                                                                   else
14022                                                                     {
14023                                                                       /* 33222222222211111111110000000000
14024                                                                          10987654321098765432109876543210
14025                                                                          011001x1xx010000001xxxxxxxx1xxxx
14026                                                                          fcmgt.  */
14027                                                                       return 1409;
14028                                                                     }
14029                                                                 }
14030                                                             }
14031                                                           else
14032                                                             {
14033                                                               /* 33222222222211111111110000000000
14034                                                                  10987654321098765432109876543210
14035                                                                  011001x1xx0x1000001xxxxxxxxxxxxx
14036                                                                  fadda.  */
14037                                                               return 1399;
14038                                                             }
14039                                                         }
14040                                                       else
14041                                                         {
14042                                                           /* 33222222222211111111110000000000
14043                                                              10987654321098765432109876543210
14044                                                              011001x1xx0xx100001xxxxxxxxxxxxx
14045                                                              fmaxnmv.  */
14046                                                           return 1446;
14047                                                         }
14048                                                     }
14049                                                   else
14050                                                     {
14051                                                       if (((word >> 18) & 0x1) == 0)
14052                                                         {
14053                                                           /* 33222222222211111111110000000000
14054                                                              10987654321098765432109876543210
14055                                                              011001x1xx0xx010001xxxxxxxxxxxxx
14056                                                              fcmeq.  */
14057                                                           return 1405;
14058                                                         }
14059                                                       else
14060                                                         {
14061                                                           if (((word >> 19) & 0x1) == 0)
14062                                                             {
14063                                                               /* 33222222222211111111110000000000
14064                                                                  10987654321098765432109876543210
14065                                                                  011001x1xx0x0110001xxxxxxxxxxxxx
14066                                                                  fmaxv.  */
14067                                                               return 1447;
14068                                                             }
14069                                                           else
14070                                                             {
14071                                                               /* 33222222222211111111110000000000
14072                                                                  10987654321098765432109876543210
14073                                                                  011001x1xx0x1110001xxxxxxxxxxxxx
14074                                                                  frecpe.  */
14075                                                               return 1475;
14076                                                             }
14077                                                         }
14078                                                     }
14079                                                 }
14080                                               else
14081                                                 {
14082                                                   if (((word >> 17) & 0x1) == 0)
14083                                                     {
14084                                                       if (((word >> 18) & 0x1) == 0)
14085                                                         {
14086                                                           if (((word >> 4) & 0x1) == 0)
14087                                                             {
14088                                                               /* 33222222222211111111110000000000
14089                                                                  10987654321098765432109876543210
14090                                                                  011001x1xx0xx001001xxxxxxxx0xxxx
14091                                                                  fcmlt.  */
14092                                                               return 1412;
14093                                                             }
14094                                                           else
14095                                                             {
14096                                                               /* 33222222222211111111110000000000
14097                                                                  10987654321098765432109876543210
14098                                                                  011001x1xx0xx001001xxxxxxxx1xxxx
14099                                                                  fcmle.  */
14100                                                               return 1411;
14101                                                             }
14102                                                         }
14103                                                       else
14104                                                         {
14105                                                           /* 33222222222211111111110000000000
14106                                                              10987654321098765432109876543210
14107                                                              011001x1xx0xx101001xxxxxxxxxxxxx
14108                                                              fminnmv.  */
14109                                                           return 1452;
14110                                                         }
14111                                                     }
14112                                                   else
14113                                                     {
14114                                                       if (((word >> 18) & 0x1) == 0)
14115                                                         {
14116                                                           /* 33222222222211111111110000000000
14117                                                              10987654321098765432109876543210
14118                                                              011001x1xx0xx011001xxxxxxxxxxxxx
14119                                                              fcmne.  */
14120                                                           return 1413;
14121                                                         }
14122                                                       else
14123                                                         {
14124                                                           if (((word >> 19) & 0x1) == 0)
14125                                                             {
14126                                                               /* 33222222222211111111110000000000
14127                                                                  10987654321098765432109876543210
14128                                                                  011001x1xx0x0111001xxxxxxxxxxxxx
14129                                                                  fminv.  */
14130                                                               return 1453;
14131                                                             }
14132                                                           else
14133                                                             {
14134                                                               /* 33222222222211111111110000000000
14135                                                                  10987654321098765432109876543210
14136                                                                  011001x1xx0x1111001xxxxxxxxxxxxx
14137                                                                  frsqrte.  */
14138                                                               return 1485;
14139                                                             }
14140                                                         }
14141                                                     }
14142                                                 }
14143                                             }
14144                                           else
14145                                             {
14146                                               if (((word >> 22) & 0x1) == 0)
14147                                                 {
14148                                                   if (((word >> 23) & 0x1) == 0)
14149                                                     {
14150                                                       /* 33222222222211111111110000000000
14151                                                          10987654321098765432109876543210
14152                                                          111001x1000xxxxx001xxxxxxxxxxxxx
14153                                                          stnt1w.  */
14154                                                       return 2261;
14155                                                     }
14156                                                   else
14157                                                     {
14158                                                       /* 33222222222211111111110000000000
14159                                                          10987654321098765432109876543210
14160                                                          111001x1100xxxxx001xxxxxxxxxxxxx
14161                                                          stnt1d.  */
14162                                                       return 2257;
14163                                                     }
14164                                                 }
14165                                               else
14166                                                 {
14167                                                   /* 33222222222211111111110000000000
14168                                                      10987654321098765432109876543210
14169                                                      111001x1x10xxxxx001xxxxxxxxxxxxx
14170                                                      stnt1w.  */
14171                                                   return 2260;
14172                                                 }
14173                                             }
14174                                         }
14175                                     }
14176                                   else
14177                                     {
14178                                       if (((word >> 30) & 0x1) == 0)
14179                                         {
14180                                           if (((word >> 31) & 0x1) == 0)
14181                                             {
14182                                               if (((word >> 4) & 0x1) == 0)
14183                                                 {
14184                                                   if (((word >> 12) & 0x1) == 0)
14185                                                     {
14186                                                       /* 33222222222211111111110000000000
14187                                                          10987654321098765432109876543210
14188                                                          001001x1xx1xxxxx0010xxxxxxx0xxxx
14189                                                          ctermeq.  */
14190                                                       return 1370;
14191                                                     }
14192                                                   else
14193                                                     {
14194                                                       /* 33222222222211111111110000000000
14195                                                          10987654321098765432109876543210
14196                                                          001001x1xx1xxxxx0011xxxxxxx0xxxx
14197                                                          whilewr.  */
14198                                                       return 2339;
14199                                                     }
14200                                                 }
14201                                               else
14202                                                 {
14203                                                   if (((word >> 12) & 0x1) == 0)
14204                                                     {
14205                                                       /* 33222222222211111111110000000000
14206                                                          10987654321098765432109876543210
14207                                                          001001x1xx1xxxxx0010xxxxxxx1xxxx
14208                                                          ctermne.  */
14209                                                       return 1371;
14210                                                     }
14211                                                   else
14212                                                     {
14213                                                       /* 33222222222211111111110000000000
14214                                                          10987654321098765432109876543210
14215                                                          001001x1xx1xxxxx0011xxxxxxx1xxxx
14216                                                          whilerw.  */
14217                                                       return 2338;
14218                                                     }
14219                                                 }
14220                                             }
14221                                           else
14222                                             {
14223                                               if (((word >> 23) & 0x1) == 0)
14224                                                 {
14225                                                   /* 33222222222211111111110000000000
14226                                                      10987654321098765432109876543210
14227                                                      101001x10x1xxxxx001xxxxxxxxxxxxx
14228                                                      ld1row.  */
14229                                                   return 2482;
14230                                                 }
14231                                               else
14232                                                 {
14233                                                   /* 33222222222211111111110000000000
14234                                                      10987654321098765432109876543210
14235                                                      101001x11x1xxxxx001xxxxxxxxxxxxx
14236                                                      ld1rod.  */
14237                                                   return 2483;
14238                                                 }
14239                                             }
14240                                         }
14241                                       else
14242                                         {
14243                                           /* 33222222222211111111110000000000
14244                                              10987654321098765432109876543210
14245                                              x11001x1xx1xxxxx001xxxxxxxxxxxxx
14246                                              fmls.  */
14247                                           return 1458;
14248                                         }
14249                                     }
14250                                 }
14251                             }
14252                           else
14253                             {
14254                               if (((word >> 30) & 0x1) == 0)
14255                                 {
14256                                   if (((word >> 21) & 0x1) == 0)
14257                                     {
14258                                       if (((word >> 22) & 0x1) == 0)
14259                                         {
14260                                           if (((word >> 23) & 0x1) == 0)
14261                                             {
14262                                               if (((word >> 31) & 0x1) == 0)
14263                                                 {
14264                                                   if (((word >> 9) & 0x1) == 0)
14265                                                     {
14266                                                       if (((word >> 20) & 0x1) == 0)
14267                                                         {
14268                                                           if (((word >> 4) & 0x1) == 0)
14269                                                             {
14270                                                               /* 33222222222211111111110000000000
14271                                                                  10987654321098765432109876543210
14272                                                                  001001x10000xxxx01xxxx0xxxx0xxxx
14273                                                                  and.  */
14274                                                               return 1301;
14275                                                             }
14276                                                           else
14277                                                             {
14278                                                               /* 33222222222211111111110000000000
14279                                                                  10987654321098765432109876543210
14280                                                                  001001x10000xxxx01xxxx0xxxx1xxxx
14281                                                                  bic.  */
14282                                                               return 1313;
14283                                                             }
14284                                                         }
14285                                                       else
14286                                                         {
14287                                                           if (((word >> 19) & 0x1) == 0)
14288                                                             {
14289                                                               /* 33222222222211111111110000000000
14290                                                                  10987654321098765432109876543210
14291                                                                  001001x100010xxx01xxxx0xxxxxxxxx
14292                                                                  brka.  */
14293                                                               return 1315;
14294                                                             }
14295                                                           else
14296                                                             {
14297                                                               /* 33222222222211111111110000000000
14298                                                                  10987654321098765432109876543210
14299                                                                  001001x100011xxx01xxxx0xxxxxxxxx
14300                                                                  brkn.  */
14301                                                               return 1319;
14302                                                             }
14303                                                         }
14304                                                     }
14305                                                   else
14306                                                     {
14307                                                       if (((word >> 4) & 0x1) == 0)
14308                                                         {
14309                                                           /* 33222222222211111111110000000000
14310                                                              10987654321098765432109876543210
14311                                                              001001x1000xxxxx01xxxx1xxxx0xxxx
14312                                                              eor.  */
14313                                                           return 1388;
14314                                                         }
14315                                                       else
14316                                                         {
14317                                                           /* 33222222222211111111110000000000
14318                                                              10987654321098765432109876543210
14319                                                              001001x1000xxxxx01xxxx1xxxx1xxxx
14320                                                              sel.  */
14321                                                           return 1837;
14322                                                         }
14323                                                     }
14324                                                 }
14325                                               else
14326                                                 {
14327                                                   if (((word >> 13) & 0x1) == 0)
14328                                                     {
14329                                                       /* 33222222222211111111110000000000
14330                                                          10987654321098765432109876543210
14331                                                          101001x1000xxxxx010xxxxxxxxxxxxx
14332                                                          ld1sh.  */
14333                                                       return 1587;
14334                                                     }
14335                                                   else
14336                                                     {
14337                                                       /* 33222222222211111111110000000000
14338                                                          10987654321098765432109876543210
14339                                                          101001x1000xxxxx011xxxxxxxxxxxxx
14340                                                          ldff1sh.  */
14341                                                       return 1687;
14342                                                     }
14343                                                 }
14344                                             }
14345                                           else
14346                                             {
14347                                               if (((word >> 31) & 0x1) == 0)
14348                                                 {
14349                                                   if (((word >> 9) & 0x1) == 0)
14350                                                     {
14351                                                       if (((word >> 20) & 0x1) == 0)
14352                                                         {
14353                                                           if (((word >> 4) & 0x1) == 0)
14354                                                             {
14355                                                               /* 33222222222211111111110000000000
14356                                                                  10987654321098765432109876543210
14357                                                                  001001x11000xxxx01xxxx0xxxx0xxxx
14358                                                                  orr.  */
14359                                                               return 1773;
14360                                                             }
14361                                                           else
14362                                                             {
14363                                                               /* 33222222222211111111110000000000
14364                                                                  10987654321098765432109876543210
14365                                                                  001001x11000xxxx01xxxx0xxxx1xxxx
14366                                                                  orn.  */
14367                                                               return 1768;
14368                                                             }
14369                                                         }
14370                                                       else
14371                                                         {
14372                                                           /* 33222222222211111111110000000000
14373                                                              10987654321098765432109876543210
14374                                                              001001x11001xxxx01xxxx0xxxxxxxxx
14375                                                              brkb.  */
14376                                                           return 1317;
14377                                                         }
14378                                                     }
14379                                                   else
14380                                                     {
14381                                                       if (((word >> 4) & 0x1) == 0)
14382                                                         {
14383                                                           /* 33222222222211111111110000000000
14384                                                              10987654321098765432109876543210
14385                                                              001001x1100xxxxx01xxxx1xxxx0xxxx
14386                                                              nor.  */
14387                                                           return 1765;
14388                                                         }
14389                                                       else
14390                                                         {
14391                                                           /* 33222222222211111111110000000000
14392                                                              10987654321098765432109876543210
14393                                                              001001x1100xxxxx01xxxx1xxxx1xxxx
14394                                                              nand.  */
14395                                                           return 1762;
14396                                                         }
14397                                                     }
14398                                                 }
14399                                               else
14400                                                 {
14401                                                   if (((word >> 13) & 0x1) == 0)
14402                                                     {
14403                                                       /* 33222222222211111111110000000000
14404                                                          10987654321098765432109876543210
14405                                                          101001x1100xxxxx010xxxxxxxxxxxxx
14406                                                          ld1sb.  */
14407                                                       return 1575;
14408                                                     }
14409                                                   else
14410                                                     {
14411                                                       /* 33222222222211111111110000000000
14412                                                          10987654321098765432109876543210
14413                                                          101001x1100xxxxx011xxxxxxxxxxxxx
14414                                                          ldff1sb.  */
14415                                                       return 1675;
14416                                                     }
14417                                                 }
14418                                             }
14419                                         }
14420                                       else
14421                                         {
14422                                           if (((word >> 23) & 0x1) == 0)
14423                                             {
14424                                               if (((word >> 31) & 0x1) == 0)
14425                                                 {
14426                                                   if (((word >> 4) & 0x1) == 0)
14427                                                     {
14428                                                       if (((word >> 9) & 0x1) == 0)
14429                                                         {
14430                                                           if (((word >> 20) & 0x1) == 0)
14431                                                             {
14432                                                               /* 33222222222211111111110000000000
14433                                                                  10987654321098765432109876543210
14434                                                                  001001x10100xxxx01xxxx0xxxx0xxxx
14435                                                                  ands.  */
14436                                                               return 1302;
14437                                                             }
14438                                                           else
14439                                                             {
14440                                                               if (((word >> 19) & 0x1) == 0)
14441                                                                 {
14442                                                                   /* 33222222222211111111110000000000
14443                                                                      10987654321098765432109876543210
14444                                                                      001001x101010xxx01xxxx0xxxx0xxxx
14445                                                                      brkas.  */
14446                                                                   return 1316;
14447                                                                 }
14448                                                               else
14449                                                                 {
14450                                                                   /* 33222222222211111111110000000000
14451                                                                      10987654321098765432109876543210
14452                                                                      001001x101011xxx01xxxx0xxxx0xxxx
14453                                                                      brkns.  */
14454                                                                   return 1320;
14455                                                                 }
14456                                                             }
14457                                                         }
14458                                                       else
14459                                                         {
14460                                                           /* 33222222222211111111110000000000
14461                                                              10987654321098765432109876543210
14462                                                              001001x1010xxxxx01xxxx1xxxx0xxxx
14463                                                              eors.  */
14464                                                           return 1389;
14465                                                         }
14466                                                     }
14467                                                   else
14468                                                     {
14469                                                       /* 33222222222211111111110000000000
14470                                                          10987654321098765432109876543210
14471                                                          001001x1010xxxxx01xxxxxxxxx1xxxx
14472                                                          bics.  */
14473                                                       return 1314;
14474                                                     }
14475                                                 }
14476                                               else
14477                                                 {
14478                                                   if (((word >> 13) & 0x1) == 0)
14479                                                     {
14480                                                       /* 33222222222211111111110000000000
14481                                                          10987654321098765432109876543210
14482                                                          101001x1010xxxxx010xxxxxxxxxxxxx
14483                                                          ld1w.  */
14484                                                       return 1606;
14485                                                     }
14486                                                   else
14487                                                     {
14488                                                       /* 33222222222211111111110000000000
14489                                                          10987654321098765432109876543210
14490                                                          101001x1010xxxxx011xxxxxxxxxxxxx
14491                                                          ldff1w.  */
14492                                                       return 1706;
14493                                                     }
14494                                                 }
14495                                             }
14496                                           else
14497                                             {
14498                                               if (((word >> 31) & 0x1) == 0)
14499                                                 {
14500                                                   if (((word >> 4) & 0x1) == 0)
14501                                                     {
14502                                                       if (((word >> 9) & 0x1) == 0)
14503                                                         {
14504                                                           if (((word >> 20) & 0x1) == 0)
14505                                                             {
14506                                                               /* 33222222222211111111110000000000
14507                                                                  10987654321098765432109876543210
14508                                                                  001001x11100xxxx01xxxx0xxxx0xxxx
14509                                                                  orrs.  */
14510                                                               return 1774;
14511                                                             }
14512                                                           else
14513                                                             {
14514                                                               /* 33222222222211111111110000000000
14515                                                                  10987654321098765432109876543210
14516                                                                  001001x11101xxxx01xxxx0xxxx0xxxx
14517                                                                  brkbs.  */
14518                                                               return 1318;
14519                                                             }
14520                                                         }
14521                                                       else
14522                                                         {
14523                                                           /* 33222222222211111111110000000000
14524                                                              10987654321098765432109876543210
14525                                                              001001x1110xxxxx01xxxx1xxxx0xxxx
14526                                                              nors.  */
14527                                                           return 1766;
14528                                                         }
14529                                                     }
14530                                                   else
14531                                                     {
14532                                                       if (((word >> 9) & 0x1) == 0)
14533                                                         {
14534                                                           /* 33222222222211111111110000000000
14535                                                              10987654321098765432109876543210
14536                                                              001001x1110xxxxx01xxxx0xxxx1xxxx
14537                                                              orns.  */
14538                                                           return 1769;
14539                                                         }
14540                                                       else
14541                                                         {
14542                                                           /* 33222222222211111111110000000000
14543                                                              10987654321098765432109876543210
14544                                                              001001x1110xxxxx01xxxx1xxxx1xxxx
14545                                                              nands.  */
14546                                                           return 1763;
14547                                                         }
14548                                                     }
14549                                                 }
14550                                               else
14551                                                 {
14552                                                   if (((word >> 13) & 0x1) == 0)
14553                                                     {
14554                                                       /* 33222222222211111111110000000000
14555                                                          10987654321098765432109876543210
14556                                                          101001x1110xxxxx010xxxxxxxxxxxxx
14557                                                          ld1sb.  */
14558                                                       return 1577;
14559                                                     }
14560                                                   else
14561                                                     {
14562                                                       /* 33222222222211111111110000000000
14563                                                          10987654321098765432109876543210
14564                                                          101001x1110xxxxx011xxxxxxxxxxxxx
14565                                                          ldff1sb.  */
14566                                                       return 1679;
14567                                                     }
14568                                                 }
14569                                             }
14570                                         }
14571                                     }
14572                                   else
14573                                     {
14574                                       if (((word >> 31) & 0x1) == 0)
14575                                         {
14576                                           /* 33222222222211111111110000000000
14577                                              10987654321098765432109876543210
14578                                              001001x1xx1xxxxx01xxxxxxxxxxxxxx
14579                                              psel.  */
14580                                           return 2414;
14581                                         }
14582                                       else
14583                                         {
14584                                           if (((word >> 13) & 0x1) == 0)
14585                                             {
14586                                               if (((word >> 22) & 0x1) == 0)
14587                                                 {
14588                                                   if (((word >> 23) & 0x1) == 0)
14589                                                     {
14590                                                       /* 33222222222211111111110000000000
14591                                                          10987654321098765432109876543210
14592                                                          101001x1001xxxxx010xxxxxxxxxxxxx
14593                                                          ld1sh.  */
14594                                                       return 1588;
14595                                                     }
14596                                                   else
14597                                                     {
14598                                                       /* 33222222222211111111110000000000
14599                                                          10987654321098765432109876543210
14600                                                          101001x1101xxxxx010xxxxxxxxxxxxx
14601                                                          ld1sb.  */
14602                                                       return 1576;
14603                                                     }
14604                                                 }
14605                                               else
14606                                                 {
14607                                                   if (((word >> 23) & 0x1) == 0)
14608                                                     {
14609                                                       /* 33222222222211111111110000000000
14610                                                          10987654321098765432109876543210
14611                                                          101001x1011xxxxx010xxxxxxxxxxxxx
14612                                                          ld1w.  */
14613                                                       return 1607;
14614                                                     }
14615                                                   else
14616                                                     {
14617                                                       /* 33222222222211111111110000000000
14618                                                          10987654321098765432109876543210
14619                                                          101001x1111xxxxx010xxxxxxxxxxxxx
14620                                                          ld1d.  */
14621                                                       return 1529;
14622                                                     }
14623                                                 }
14624                                             }
14625                                           else
14626                                             {
14627                                               if (((word >> 22) & 0x1) == 0)
14628                                                 {
14629                                                   if (((word >> 23) & 0x1) == 0)
14630                                                     {
14631                                                       /* 33222222222211111111110000000000
14632                                                          10987654321098765432109876543210
14633                                                          101001x1001xxxxx011xxxxxxxxxxxxx
14634                                                          ldff1sh.  */
14635                                                       return 1689;
14636                                                     }
14637                                                   else
14638                                                     {
14639                                                       /* 33222222222211111111110000000000
14640                                                          10987654321098765432109876543210
14641                                                          101001x1101xxxxx011xxxxxxxxxxxxx
14642                                                          ldff1sb.  */
14643                                                       return 1677;
14644                                                     }
14645                                                 }
14646                                               else
14647                                                 {
14648                                                   if (((word >> 23) & 0x1) == 0)
14649                                                     {
14650                                                       /* 33222222222211111111110000000000
14651                                                          10987654321098765432109876543210
14652                                                          101001x1011xxxxx011xxxxxxxxxxxxx
14653                                                          ldff1w.  */
14654                                                       return 1708;
14655                                                     }
14656                                                   else
14657                                                     {
14658                                                       /* 33222222222211111111110000000000
14659                                                          10987654321098765432109876543210
14660                                                          101001x1111xxxxx011xxxxxxxxxxxxx
14661                                                          ldff1d.  */
14662                                                       return 1653;
14663                                                     }
14664                                                 }
14665                                             }
14666                                         }
14667                                     }
14668                                 }
14669                               else
14670                                 {
14671                                   if (((word >> 13) & 0x1) == 0)
14672                                     {
14673                                       if (((word >> 31) & 0x1) == 0)
14674                                         {
14675                                           if (((word >> 21) & 0x1) == 0)
14676                                             {
14677                                               if (((word >> 4) & 0x1) == 0)
14678                                                 {
14679                                                   /* 33222222222211111111110000000000
14680                                                      10987654321098765432109876543210
14681                                                      011001x1xx0xxxxx010xxxxxxxx0xxxx
14682                                                      fcmge.  */
14683                                                   return 1408;
14684                                                 }
14685                                               else
14686                                                 {
14687                                                   /* 33222222222211111111110000000000
14688                                                      10987654321098765432109876543210
14689                                                      011001x1xx0xxxxx010xxxxxxxx1xxxx
14690                                                      fcmgt.  */
14691                                                   return 1410;
14692                                                 }
14693                                             }
14694                                           else
14695                                             {
14696                                               /* 33222222222211111111110000000000
14697                                                  10987654321098765432109876543210
14698                                                  011001x1xx1xxxxx010xxxxxxxxxxxxx
14699                                                  fnmla.  */
14700                                               return 1472;
14701                                             }
14702                                         }
14703                                       else
14704                                         {
14705                                           if (((word >> 22) & 0x1) == 0)
14706                                             {
14707                                               /* 33222222222211111111110000000000
14708                                                  10987654321098765432109876543210
14709                                                  111001x1x0xxxxxx010xxxxxxxxxxxxx
14710                                                  str.  */
14711                                               return 1958;
14712                                             }
14713                                           else
14714                                             {
14715                                               if (((word >> 21) & 0x1) == 0)
14716                                                 {
14717                                                   /* 33222222222211111111110000000000
14718                                                      10987654321098765432109876543210
14719                                                      111001x1x10xxxxx010xxxxxxxxxxxxx
14720                                                      st1w.  */
14721                                                   return 1917;
14722                                                 }
14723                                               else
14724                                                 {
14725                                                   if (((word >> 23) & 0x1) == 0)
14726                                                     {
14727                                                       /* 33222222222211111111110000000000
14728                                                          10987654321098765432109876543210
14729                                                          111001x1011xxxxx010xxxxxxxxxxxxx
14730                                                          st1w.  */
14731                                                       return 1919;
14732                                                     }
14733                                                   else
14734                                                     {
14735                                                       /* 33222222222211111111110000000000
14736                                                          10987654321098765432109876543210
14737                                                          111001x1111xxxxx010xxxxxxxxxxxxx
14738                                                          st1d.  */
14739                                                       return 1896;
14740                                                     }
14741                                                 }
14742                                             }
14743                                         }
14744                                     }
14745                                   else
14746                                     {
14747                                       if (((word >> 21) & 0x1) == 0)
14748                                         {
14749                                           if (((word >> 31) & 0x1) == 0)
14750                                             {
14751                                               if (((word >> 4) & 0x1) == 0)
14752                                                 {
14753                                                   /* 33222222222211111111110000000000
14754                                                      10987654321098765432109876543210
14755                                                      011001x1xx0xxxxx011xxxxxxxx0xxxx
14756                                                      fcmeq.  */
14757                                                   return 1406;
14758                                                 }
14759                                               else
14760                                                 {
14761                                                   /* 33222222222211111111110000000000
14762                                                      10987654321098765432109876543210
14763                                                      011001x1xx0xxxxx011xxxxxxxx1xxxx
14764                                                      fcmne.  */
14765                                                   return 1414;
14766                                                 }
14767                                             }
14768                                           else
14769                                             {
14770                                               if (((word >> 22) & 0x1) == 0)
14771                                                 {
14772                                                   if (((word >> 23) & 0x1) == 0)
14773                                                     {
14774                                                       /* 33222222222211111111110000000000
14775                                                          10987654321098765432109876543210
14776                                                          111001x1000xxxxx011xxxxxxxxxxxxx
14777                                                          stnt1w.  */
14778                                                       return 1955;
14779                                                     }
14780                                                   else
14781                                                     {
14782                                                       /* 33222222222211111111110000000000
14783                                                          10987654321098765432109876543210
14784                                                          111001x1100xxxxx011xxxxxxxxxxxxx
14785                                                          stnt1d.  */
14786                                                       return 1951;
14787                                                     }
14788                                                 }
14789                                               else
14790                                                 {
14791                                                   if (((word >> 23) & 0x1) == 0)
14792                                                     {
14793                                                       /* 33222222222211111111110000000000
14794                                                          10987654321098765432109876543210
14795                                                          111001x1010xxxxx011xxxxxxxxxxxxx
14796                                                          st3w.  */
14797                                                       return 1939;
14798                                                     }
14799                                                   else
14800                                                     {
14801                                                       /* 33222222222211111111110000000000
14802                                                          10987654321098765432109876543210
14803                                                          111001x1110xxxxx011xxxxxxxxxxxxx
14804                                                          st3d.  */
14805                                                       return 1935;
14806                                                     }
14807                                                 }
14808                                             }
14809                                         }
14810                                       else
14811                                         {
14812                                           if (((word >> 31) & 0x1) == 0)
14813                                             {
14814                                               /* 33222222222211111111110000000000
14815                                                  10987654321098765432109876543210
14816                                                  011001x1xx1xxxxx011xxxxxxxxxxxxx
14817                                                  fnmls.  */
14818                                               return 1473;
14819                                             }
14820                                           else
14821                                             {
14822                                               if (((word >> 22) & 0x1) == 0)
14823                                                 {
14824                                                   if (((word >> 23) & 0x1) == 0)
14825                                                     {
14826                                                       /* 33222222222211111111110000000000
14827                                                          10987654321098765432109876543210
14828                                                          111001x1001xxxxx011xxxxxxxxxxxxx
14829                                                          st2w.  */
14830                                                       return 1931;
14831                                                     }
14832                                                   else
14833                                                     {
14834                                                       /* 33222222222211111111110000000000
14835                                                          10987654321098765432109876543210
14836                                                          111001x1101xxxxx011xxxxxxxxxxxxx
14837                                                          st2d.  */
14838                                                       return 1927;
14839                                                     }
14840                                                 }
14841                                               else
14842                                                 {
14843                                                   if (((word >> 23) & 0x1) == 0)
14844                                                     {
14845                                                       /* 33222222222211111111110000000000
14846                                                          10987654321098765432109876543210
14847                                                          111001x1011xxxxx011xxxxxxxxxxxxx
14848                                                          st4w.  */
14849                                                       return 1947;
14850                                                     }
14851                                                   else
14852                                                     {
14853                                                       /* 33222222222211111111110000000000
14854                                                          10987654321098765432109876543210
14855                                                          111001x1111xxxxx011xxxxxxxxxxxxx
14856                                                          st4d.  */
14857                                                       return 1943;
14858                                                     }
14859                                                 }
14860                                             }
14861                                         }
14862                                     }
14863                                 }
14864                             }
14865                         }
14866                       else
14867                         {
14868                           if (((word >> 21) & 0x1) == 0)
14869                             {
14870                               if (((word >> 30) & 0x1) == 0)
14871                                 {
14872                                   if (((word >> 14) & 0x1) == 0)
14873                                     {
14874                                       if (((word >> 13) & 0x1) == 0)
14875                                         {
14876                                           if (((word >> 4) & 0x1) == 0)
14877                                             {
14878                                               /* 33222222222211111111110000000000
14879                                                  10987654321098765432109876543210
14880                                                  x01001x1xx0xxxxx100xxxxxxxx0xxxx
14881                                                  cmpeq.  */
14882                                               return 1335;
14883                                             }
14884                                           else
14885                                             {
14886                                               /* 33222222222211111111110000000000
14887                                                  10987654321098765432109876543210
14888                                                  x01001x1xx0xxxxx100xxxxxxxx1xxxx
14889                                                  cmpne.  */
14890                                               return 1358;
14891                                             }
14892                                         }
14893                                       else
14894                                         {
14895                                           if (((word >> 20) & 0x1) == 0)
14896                                             {
14897                                               if (((word >> 22) & 0x1) == 0)
14898                                                 {
14899                                                   if (((word >> 23) & 0x1) == 0)
14900                                                     {
14901                                                       /* 33222222222211111111110000000000
14902                                                          10987654321098765432109876543210
14903                                                          x01001x10000xxxx101xxxxxxxxxxxxx
14904                                                          ld1sh.  */
14905                                                       return 1594;
14906                                                     }
14907                                                   else
14908                                                     {
14909                                                       /* 33222222222211111111110000000000
14910                                                          10987654321098765432109876543210
14911                                                          x01001x11000xxxx101xxxxxxxxxxxxx
14912                                                          ld1sb.  */
14913                                                       return 1581;
14914                                                     }
14915                                                 }
14916                                               else
14917                                                 {
14918                                                   if (((word >> 23) & 0x1) == 0)
14919                                                     {
14920                                                       /* 33222222222211111111110000000000
14921                                                          10987654321098765432109876543210
14922                                                          x01001x10100xxxx101xxxxxxxxxxxxx
14923                                                          ld1w.  */
14924                                                       return 1613;
14925                                                     }
14926                                                   else
14927                                                     {
14928                                                       /* 33222222222211111111110000000000
14929                                                          10987654321098765432109876543210
14930                                                          x01001x11100xxxx101xxxxxxxxxxxxx
14931                                                          ld1sb.  */
14932                                                       return 1583;
14933                                                     }
14934                                                 }
14935                                             }
14936                                           else
14937                                             {
14938                                               if (((word >> 22) & 0x1) == 0)
14939                                                 {
14940                                                   if (((word >> 23) & 0x1) == 0)
14941                                                     {
14942                                                       /* 33222222222211111111110000000000
14943                                                          10987654321098765432109876543210
14944                                                          x01001x10001xxxx101xxxxxxxxxxxxx
14945                                                          ldnf1sh.  */
14946                                                       return 1727;
14947                                                     }
14948                                                   else
14949                                                     {
14950                                                       /* 33222222222211111111110000000000
14951                                                          10987654321098765432109876543210
14952                                                          x01001x11001xxxx101xxxxxxxxxxxxx
14953                                                          ldnf1sb.  */
14954                                                       return 1724;
14955                                                     }
14956                                                 }
14957                                               else
14958                                                 {
14959                                                   if (((word >> 23) & 0x1) == 0)
14960                                                     {
14961                                                       /* 33222222222211111111110000000000
14962                                                          10987654321098765432109876543210
14963                                                          x01001x10101xxxx101xxxxxxxxxxxxx
14964                                                          ldnf1w.  */
14965                                                       return 1730;
14966                                                     }
14967                                                   else
14968                                                     {
14969                                                       /* 33222222222211111111110000000000
14970                                                          10987654321098765432109876543210
14971                                                          x01001x11101xxxx101xxxxxxxxxxxxx
14972                                                          ldnf1sb.  */
14973                                                       return 1726;
14974                                                     }
14975                                                 }
14976                                             }
14977                                         }
14978                                     }
14979                                   else
14980                                     {
14981                                       if (((word >> 31) & 0x1) == 0)
14982                                         {
14983                                           if (((word >> 4) & 0x1) == 0)
14984                                             {
14985                                               if (((word >> 20) & 0x1) == 0)
14986                                                 {
14987                                                   if (((word >> 22) & 0x1) == 0)
14988                                                     {
14989                                                       /* 33222222222211111111110000000000
14990                                                          10987654321098765432109876543210
14991                                                          001001x1x000xxxx11xxxxxxxxx0xxxx
14992                                                          brkpa.  */
14993                                                       return 1321;
14994                                                     }
14995                                                   else
14996                                                     {
14997                                                       /* 33222222222211111111110000000000
14998                                                          10987654321098765432109876543210
14999                                                          001001x1x100xxxx11xxxxxxxxx0xxxx
15000                                                          brkpas.  */
15001                                                       return 1322;
15002                                                     }
15003                                                 }
15004                                               else
15005                                                 {
15006                                                   if (((word >> 16) & 0x1) == 0)
15007                                                     {
15008                                                       if (((word >> 19) & 0x1) == 0)
15009                                                         {
15010                                                           /* 33222222222211111111110000000000
15011                                                              10987654321098765432109876543210
15012                                                              001001x1xx010xx011xxxxxxxxx0xxxx
15013                                                              ptest.  */
15014                                                           return 1807;
15015                                                         }
15016                                                       else
15017                                                         {
15018                                                           if (((word >> 10) & 0x1) == 0)
15019                                                             {
15020                                                               if (((word >> 12) & 0x1) == 0)
15021                                                                 {
15022                                                                   if (((word >> 13) & 0x1) == 0)
15023                                                                     {
15024                                                                       /* 33222222222211111111110000000000
15025                                                                          10987654321098765432109876543210
15026                                                                          001001x1xx011xx01100x0xxxxx0xxxx
15027                                                                          pfirst.  */
15028                                                                       return 1777;
15029                                                                     }
15030                                                                   else
15031                                                                     {
15032                                                                       /* 33222222222211111111110000000000
15033                                                                          10987654321098765432109876543210
15034                                                                          001001x1xx011xx01110x0xxxxx0xxxx
15035                                                                          ptrue.  */
15036                                                                       return 1808;
15037                                                                     }
15038                                                                 }
15039                                                               else
15040                                                                 {
15041                                                                   if (((word >> 22) & 0x1) == 0)
15042                                                                     {
15043                                                                       /* 33222222222211111111110000000000
15044                                                                          10987654321098765432109876543210
15045                                                                          001001x1x0011xx011x1x0xxxxx0xxxx
15046                                                                          rdffr.  */
15047                                                                       return 1814;
15048                                                                     }
15049                                                                   else
15050                                                                     {
15051                                                                       /* 33222222222211111111110000000000
15052                                                                          10987654321098765432109876543210
15053                                                                          001001x1x1011xx011x1x0xxxxx0xxxx
15054                                                                          rdffrs.  */
15055                                                                       return 1815;
15056                                                                     }
15057                                                                 }
15058                                                             }
15059                                                           else
15060                                                             {
15061                                                               /* 33222222222211111111110000000000
15062                                                                  10987654321098765432109876543210
15063                                                                  001001x1xx011xx011xxx1xxxxx0xxxx
15064                                                                  pfalse.  */
15065                                                               return 1776;
15066                                                             }
15067                                                         }
15068                                                     }
15069                                                   else
15070                                                     {
15071                                                       if (((word >> 10) & 0x1) == 0)
15072                                                         {
15073                                                           if (((word >> 12) & 0x1) == 0)
15074                                                             {
15075                                                               /* 33222222222211111111110000000000
15076                                                                  10987654321098765432109876543210
15077                                                                  001001x1xx01xxx111x0x0xxxxx0xxxx
15078                                                                  ptrues.  */
15079                                                               return 1809;
15080                                                             }
15081                                                           else
15082                                                             {
15083                                                               /* 33222222222211111111110000000000
15084                                                                  10987654321098765432109876543210
15085                                                                  001001x1xx01xxx111x1x0xxxxx0xxxx
15086                                                                  rdffr.  */
15087                                                               return 1813;
15088                                                             }
15089                                                         }
15090                                                       else
15091                                                         {
15092                                                           /* 33222222222211111111110000000000
15093                                                              10987654321098765432109876543210
15094                                                              001001x1xx01xxx111xxx1xxxxx0xxxx
15095                                                              pnext.  */
15096                                                           return 1778;
15097                                                         }
15098                                                     }
15099                                                 }
15100                                             }
15101                                           else
15102                                             {
15103                                               if (((word >> 22) & 0x1) == 0)
15104                                                 {
15105                                                   /* 33222222222211111111110000000000
15106                                                      10987654321098765432109876543210
15107                                                      001001x1x00xxxxx11xxxxxxxxx1xxxx
15108                                                      brkpb.  */
15109                                                   return 1323;
15110                                                 }
15111                                               else
15112                                                 {
15113                                                   /* 33222222222211111111110000000000
15114                                                      10987654321098765432109876543210
15115                                                      001001x1x10xxxxx11xxxxxxxxx1xxxx
15116                                                      brkpbs.  */
15117                                                   return 1324;
15118                                                 }
15119                                             }
15120                                         }
15121                                       else
15122                                         {
15123                                           if (((word >> 13) & 0x1) == 0)
15124                                             {
15125                                               if (((word >> 22) & 0x1) == 0)
15126                                                 {
15127                                                   if (((word >> 23) & 0x1) == 0)
15128                                                     {
15129                                                       /* 33222222222211111111110000000000
15130                                                          10987654321098765432109876543210
15131                                                          101001x1000xxxxx110xxxxxxxxxxxxx
15132                                                          ldnt1w.  */
15133                                                       return 1738;
15134                                                     }
15135                                                   else
15136                                                     {
15137                                                       /* 33222222222211111111110000000000
15138                                                          10987654321098765432109876543210
15139                                                          101001x1100xxxxx110xxxxxxxxxxxxx
15140                                                          ldnt1d.  */
15141                                                       return 1734;
15142                                                     }
15143                                                 }
15144                                               else
15145                                                 {
15146                                                   if (((word >> 23) & 0x1) == 0)
15147                                                     {
15148                                                       /* 33222222222211111111110000000000
15149                                                          10987654321098765432109876543210
15150                                                          101001x1010xxxxx110xxxxxxxxxxxxx
15151                                                          ld3w.  */
15152                                                       return 1630;
15153                                                     }
15154                                                   else
15155                                                     {
15156                                                       /* 33222222222211111111110000000000
15157                                                          10987654321098765432109876543210
15158                                                          101001x1110xxxxx110xxxxxxxxxxxxx
15159                                                          ld3d.  */
15160                                                       return 1626;
15161                                                     }
15162                                                 }
15163                                             }
15164                                           else
15165                                             {
15166                                               if (((word >> 22) & 0x1) == 0)
15167                                                 {
15168                                                   if (((word >> 23) & 0x1) == 0)
15169                                                     {
15170                                                       /* 33222222222211111111110000000000
15171                                                          10987654321098765432109876543210
15172                                                          101001x1000xxxxx111xxxxxxxxxxxxx
15173                                                          ldnt1w.  */
15174                                                       return 1739;
15175                                                     }
15176                                                   else
15177                                                     {
15178                                                       /* 33222222222211111111110000000000
15179                                                          10987654321098765432109876543210
15180                                                          101001x1100xxxxx111xxxxxxxxxxxxx
15181                                                          ldnt1d.  */
15182                                                       return 1735;
15183                                                     }
15184                                                 }
15185                                               else
15186                                                 {
15187                                                   if (((word >> 23) & 0x1) == 0)
15188                                                     {
15189                                                       /* 33222222222211111111110000000000
15190                                                          10987654321098765432109876543210
15191                                                          101001x1010xxxxx111xxxxxxxxxxxxx
15192                                                          ld3w.  */
15193                                                       return 1631;
15194                                                     }
15195                                                   else
15196                                                     {
15197                                                       /* 33222222222211111111110000000000
15198                                                          10987654321098765432109876543210
15199                                                          101001x1110xxxxx111xxxxxxxxxxxxx
15200                                                          ld3d.  */
15201                                                       return 1627;
15202                                                     }
15203                                                 }
15204                                             }
15205                                         }
15206                                     }
15207                                 }
15208                               else
15209                                 {
15210                                   if (((word >> 13) & 0x1) == 0)
15211                                     {
15212                                       if (((word >> 31) & 0x1) == 0)
15213                                         {
15214                                           if (((word >> 14) & 0x1) == 0)
15215                                             {
15216                                               if (((word >> 19) & 0x1) == 0)
15217                                                 {
15218                                                   if (((word >> 20) & 0x1) == 0)
15219                                                     {
15220                                                       if (((word >> 16) & 0x1) == 0)
15221                                                         {
15222                                                           if (((word >> 17) & 0x1) == 0)
15223                                                             {
15224                                                               if (((word >> 18) & 0x1) == 0)
15225                                                                 {
15226                                                                   /* 33222222222211111111110000000000
15227                                                                      10987654321098765432109876543210
15228                                                                      011001x1xx000000100xxxxxxxxxxxxx
15229                                                                      fadd.  */
15230                                                                   return 1397;
15231                                                                 }
15232                                                               else
15233                                                                 {
15234                                                                   /* 33222222222211111111110000000000
15235                                                                      10987654321098765432109876543210
15236                                                                      011001x1xx000100100xxxxxxxxxxxxx
15237                                                                      fmaxnm.  */
15238                                                                   return 1444;
15239                                                                 }
15240                                                             }
15241                                                           else
15242                                                             {
15243                                                               if (((word >> 18) & 0x1) == 0)
15244                                                                 {
15245                                                                   /* 33222222222211111111110000000000
15246                                                                      10987654321098765432109876543210
15247                                                                      011001x1xx000010100xxxxxxxxxxxxx
15248                                                                      fmul.  */
15249                                                                   return 1464;
15250                                                                 }
15251                                                               else
15252                                                                 {
15253                                                                   /* 33222222222211111111110000000000
15254                                                                      10987654321098765432109876543210
15255                                                                      011001x1xx000110100xxxxxxxxxxxxx
15256                                                                      fmax.  */
15257                                                                   return 1442;
15258                                                                 }
15259                                                             }
15260                                                         }
15261                                                       else
15262                                                         {
15263                                                           if (((word >> 17) & 0x1) == 0)
15264                                                             {
15265                                                               if (((word >> 18) & 0x1) == 0)
15266                                                                 {
15267                                                                   /* 33222222222211111111110000000000
15268                                                                      10987654321098765432109876543210
15269                                                                      011001x1xx000001100xxxxxxxxxxxxx
15270                                                                      fsub.  */
15271                                                                   return 1490;
15272                                                                 }
15273                                                               else
15274                                                                 {
15275                                                                   /* 33222222222211111111110000000000
15276                                                                      10987654321098765432109876543210
15277                                                                      011001x1xx000101100xxxxxxxxxxxxx
15278                                                                      fminnm.  */
15279                                                                   return 1450;
15280                                                                 }
15281                                                             }
15282                                                           else
15283                                                             {
15284                                                               if (((word >> 18) & 0x1) == 0)
15285                                                                 {
15286                                                                   /* 33222222222211111111110000000000
15287                                                                      10987654321098765432109876543210
15288                                                                      011001x1xx000011100xxxxxxxxxxxxx
15289                                                                      fsubr.  */
15290                                                                   return 1492;
15291                                                                 }
15292                                                               else
15293                                                                 {
15294                                                                   /* 33222222222211111111110000000000
15295                                                                      10987654321098765432109876543210
15296                                                                      011001x1xx000111100xxxxxxxxxxxxx
15297                                                                      fmin.  */
15298                                                                   return 1448;
15299                                                                 }
15300                                                             }
15301                                                         }
15302                                                     }
15303                                                   else
15304                                                     {
15305                                                       /* 33222222222211111111110000000000
15306                                                          10987654321098765432109876543210
15307                                                          011001x1xx010xxx100xxxxxxxxxxxxx
15308                                                          ftmad.  */
15309                                                       return 1494;
15310                                                     }
15311                                                 }
15312                                               else
15313                                                 {
15314                                                   if (((word >> 16) & 0x1) == 0)
15315                                                     {
15316                                                       if (((word >> 17) & 0x1) == 0)
15317                                                         {
15318                                                           if (((word >> 18) & 0x1) == 0)
15319                                                             {
15320                                                               if (((word >> 20) & 0x1) == 0)
15321                                                                 {
15322                                                                   /* 33222222222211111111110000000000
15323                                                                      10987654321098765432109876543210
15324                                                                      011001x1xx001000100xxxxxxxxxxxxx
15325                                                                      fabd.  */
15326                                                                   return 1392;
15327                                                                 }
15328                                                               else
15329                                                                 {
15330                                                                   /* 33222222222211111111110000000000
15331                                                                      10987654321098765432109876543210
15332                                                                      011001x1xx011000100xxxxxxxxxxxxx
15333                                                                      fadd.  */
15334                                                                   return 1398;
15335                                                                 }
15336                                                             }
15337                                                           else
15338                                                             {
15339                                                               if (((word >> 20) & 0x1) == 0)
15340                                                                 {
15341                                                                   /* 33222222222211111111110000000000
15342                                                                      10987654321098765432109876543210
15343                                                                      011001x1xx001100100xxxxxxxxxxxxx
15344                                                                      fdivr.  */
15345                                                                   return 1438;
15346                                                                 }
15347                                                               else
15348                                                                 {
15349                                                                   /* 33222222222211111111110000000000
15350                                                                      10987654321098765432109876543210
15351                                                                      011001x1xx011100100xxxxxxxxxxxxx
15352                                                                      fmaxnm.  */
15353                                                                   return 1445;
15354                                                                 }
15355                                                             }
15356                                                         }
15357                                                       else
15358                                                         {
15359                                                           if (((word >> 18) & 0x1) == 0)
15360                                                             {
15361                                                               if (((word >> 20) & 0x1) == 0)
15362                                                                 {
15363                                                                   /* 33222222222211111111110000000000
15364                                                                      10987654321098765432109876543210
15365                                                                      011001x1xx001010100xxxxxxxxxxxxx
15366                                                                      fmulx.  */
15367                                                                   return 1469;
15368                                                                 }
15369                                                               else
15370                                                                 {
15371                                                                   /* 33222222222211111111110000000000
15372                                                                      10987654321098765432109876543210
15373                                                                      011001x1xx011010100xxxxxxxxxxxxx
15374                                                                      fmul.  */
15375                                                                   return 1465;
15376                                                                 }
15377                                                             }
15378                                                           else
15379                                                             {
15380                                                               /* 33222222222211111111110000000000
15381                                                                  10987654321098765432109876543210
15382                                                                  011001x1xx0x1110100xxxxxxxxxxxxx
15383                                                                  fmax.  */
15384                                                               return 1443;
15385                                                             }
15386                                                         }
15387                                                     }
15388                                                   else
15389                                                     {
15390                                                       if (((word >> 17) & 0x1) == 0)
15391                                                         {
15392                                                           if (((word >> 18) & 0x1) == 0)
15393                                                             {
15394                                                               if (((word >> 20) & 0x1) == 0)
15395                                                                 {
15396                                                                   /* 33222222222211111111110000000000
15397                                                                      10987654321098765432109876543210
15398                                                                      011001x1xx001001100xxxxxxxxxxxxx
15399                                                                      fscale.  */
15400                                                                   return 1487;
15401                                                                 }
15402                                                               else
15403                                                                 {
15404                                                                   /* 33222222222211111111110000000000
15405                                                                      10987654321098765432109876543210
15406                                                                      011001x1xx011001100xxxxxxxxxxxxx
15407                                                                      fsub.  */
15408                                                                   return 1491;
15409                                                                 }
15410                                                             }
15411                                                           else
15412                                                             {
15413                                                               if (((word >> 20) & 0x1) == 0)
15414                                                                 {
15415                                                                   /* 33222222222211111111110000000000
15416                                                                      10987654321098765432109876543210
15417                                                                      011001x1xx001101100xxxxxxxxxxxxx
15418                                                                      fdiv.  */
15419                                                                   return 1437;
15420                                                                 }
15421                                                               else
15422                                                                 {
15423                                                                   /* 33222222222211111111110000000000
15424                                                                      10987654321098765432109876543210
15425                                                                      011001x1xx011101100xxxxxxxxxxxxx
15426                                                                      fminnm.  */
15427                                                                   return 1451;
15428                                                                 }
15429                                                             }
15430                                                         }
15431                                                       else
15432                                                         {
15433                                                           if (((word >> 18) & 0x1) == 0)
15434                                                             {
15435                                                               /* 33222222222211111111110000000000
15436                                                                  10987654321098765432109876543210
15437                                                                  011001x1xx0x1011100xxxxxxxxxxxxx
15438                                                                  fsubr.  */
15439                                                               return 1493;
15440                                                             }
15441                                                           else
15442                                                             {
15443                                                               /* 33222222222211111111110000000000
15444                                                                  10987654321098765432109876543210
15445                                                                  011001x1xx0x1111100xxxxxxxxxxxxx
15446                                                                  fmin.  */
15447                                                               return 1449;
15448                                                             }
15449                                                         }
15450                                                     }
15451                                                 }
15452                                             }
15453                                           else
15454                                             {
15455                                               if (((word >> 4) & 0x1) == 0)
15456                                                 {
15457                                                   /* 33222222222211111111110000000000
15458                                                      10987654321098765432109876543210
15459                                                      011001x1xx0xxxxx110xxxxxxxx0xxxx
15460                                                      fcmuo.  */
15461                                                   return 1415;
15462                                                 }
15463                                               else
15464                                                 {
15465                                                   /* 33222222222211111111110000000000
15466                                                      10987654321098765432109876543210
15467                                                      011001x1xx0xxxxx110xxxxxxxx1xxxx
15468                                                      facge.  */
15469                                                   return 1394;
15470                                                 }
15471                                             }
15472                                         }
15473                                       else
15474                                         {
15475                                           if (((word >> 22) & 0x1) == 0)
15476                                             {
15477                                               if (((word >> 23) & 0x1) == 0)
15478                                                 {
15479                                                   /* 33222222222211111111110000000000
15480                                                      10987654321098765432109876543210
15481                                                      111001x1000xxxxx1x0xxxxxxxxxxxxx
15482                                                      st1w.  */
15483                                                   return 1913;
15484                                                 }
15485                                               else
15486                                                 {
15487                                                   /* 33222222222211111111110000000000
15488                                                      10987654321098765432109876543210
15489                                                      111001x1100xxxxx1x0xxxxxxxxxxxxx
15490                                                      st1d.  */
15491                                                   return 1892;
15492                                                 }
15493                                             }
15494                                           else
15495                                             {
15496                                               /* 33222222222211111111110000000000
15497                                                  10987654321098765432109876543210
15498                                                  111001x1x10xxxxx1x0xxxxxxxxxxxxx
15499                                                  st1w.  */
15500                                               return 1918;
15501                                             }
15502                                         }
15503                                     }
15504                                   else
15505                                     {
15506                                       if (((word >> 14) & 0x1) == 0)
15507                                         {
15508                                           if (((word >> 31) & 0x1) == 0)
15509                                             {
15510                                               if (((word >> 16) & 0x1) == 0)
15511                                                 {
15512                                                   if (((word >> 19) & 0x1) == 0)
15513                                                     {
15514                                                       if (((word >> 17) & 0x1) == 0)
15515                                                         {
15516                                                           if (((word >> 18) & 0x1) == 0)
15517                                                             {
15518                                                               if (((word >> 20) & 0x1) == 0)
15519                                                                 {
15520                                                                   /* 33222222222211111111110000000000
15521                                                                      10987654321098765432109876543210
15522                                                                      011001x1xx000000101xxxxxxxxxxxxx
15523                                                                      frintn.  */
15524                                                                   return 1481;
15525                                                                 }
15526                                                               else
15527                                                                 {
15528                                                                   /* 33222222222211111111110000000000
15529                                                                      10987654321098765432109876543210
15530                                                                      011001x1xx010000101xxxxxxxxxxxxx
15531                                                                      scvtf.  */
15532                                                                   return 1827;
15533                                                                 }
15534                                                             }
15535                                                           else
15536                                                             {
15537                                                               if (((word >> 20) & 0x1) == 0)
15538                                                                 {
15539                                                                   /* 33222222222211111111110000000000
15540                                                                      10987654321098765432109876543210
15541                                                                      011001x1xx000100101xxxxxxxxxxxxx
15542                                                                      frinta.  */
15543                                                                   return 1478;
15544                                                                 }
15545                                                               else
15546                                                                 {
15547                                                                   if (((word >> 22) & 0x1) == 0)
15548                                                                     {
15549                                                                       /* 33222222222211111111110000000000
15550                                                                          10987654321098765432109876543210
15551                                                                          011001x1x0010100101xxxxxxxxxxxxx
15552                                                                          scvtf.  */
15553                                                                       return 1826;
15554                                                                     }
15555                                                                   else
15556                                                                     {
15557                                                                       if (((word >> 23) & 0x1) == 0)
15558                                                                         {
15559                                                                           /* 33222222222211111111110000000000
15560                                                                              10987654321098765432109876543210
15561                                                                              011001x101010100101xxxxxxxxxxxxx
15562                                                                              scvtf.  */
15563                                                                           return 1825;
15564                                                                         }
15565                                                                       else
15566                                                                         {
15567                                                                           /* 33222222222211111111110000000000
15568                                                                              10987654321098765432109876543210
15569                                                                              011001x111010100101xxxxxxxxxxxxx
15570                                                                              scvtf.  */
15571                                                                           return 1829;
15572                                                                         }
15573                                                                     }
15574                                                                 }
15575                                                             }
15576                                                         }
15577                                                       else
15578                                                         {
15579                                                           if (((word >> 18) & 0x1) == 0)
15580                                                             {
15581                                                               if (((word >> 20) & 0x1) == 0)
15582                                                                 {
15583                                                                   /* 33222222222211111111110000000000
15584                                                                      10987654321098765432109876543210
15585                                                                      011001x1xx000010101xxxxxxxxxxxxx
15586                                                                      frintm.  */
15587                                                                   return 1480;
15588                                                                 }
15589                                                               else
15590                                                                 {
15591                                                                   /* 33222222222211111111110000000000
15592                                                                      10987654321098765432109876543210
15593                                                                      011001x1xx010010101xxxxxxxxxxxxx
15594                                                                      scvtf.  */
15595                                                                   return 1824;
15596                                                                 }
15597                                                             }
15598                                                           else
15599                                                             {
15600                                                               if (((word >> 20) & 0x1) == 0)
15601                                                                 {
15602                                                                   /* 33222222222211111111110000000000
15603                                                                      10987654321098765432109876543210
15604                                                                      011001x1xx000110101xxxxxxxxxxxxx
15605                                                                      frintx.  */
15606                                                                   return 1483;
15607                                                                 }
15608                                                               else
15609                                                                 {
15610                                                                   if (((word >> 23) & 0x1) == 0)
15611                                                                     {
15612                                                                       /* 33222222222211111111110000000000
15613                                                                          10987654321098765432109876543210
15614                                                                          011001x10x010110101xxxxxxxxxxxxx
15615                                                                          scvtf.  */
15616                                                                       return 1828;
15617                                                                     }
15618                                                                   else
15619                                                                     {
15620                                                                       /* 33222222222211111111110000000000
15621                                                                          10987654321098765432109876543210
15622                                                                          011001x11x010110101xxxxxxxxxxxxx
15623                                                                          scvtf.  */
15624                                                                       return 1830;
15625                                                                     }
15626                                                                 }
15627                                                             }
15628                                                         }
15629                                                     }
15630                                                   else
15631                                                     {
15632                                                       if (((word >> 20) & 0x1) == 0)
15633                                                         {
15634                                                           if (((word >> 17) & 0x1) == 0)
15635                                                             {
15636                                                               if (((word >> 18) & 0x1) == 0)
15637                                                                 {
15638                                                                   if (((word >> 22) & 0x1) == 0)
15639                                                                     {
15640                                                                       /* 33222222222211111111110000000000
15641                                                                          10987654321098765432109876543210
15642                                                                          011001x1x0001000101xxxxxxxxxxxxx
15643                                                                          fcvt.  */
15644                                                                       return 1417;
15645                                                                     }
15646                                                                   else
15647                                                                     {
15648                                                                       /* 33222222222211111111110000000000
15649                                                                          10987654321098765432109876543210
15650                                                                          011001x1x1001000101xxxxxxxxxxxxx
15651                                                                          fcvt.  */
15652                                                                       return 1419;
15653                                                                     }
15654                                                                 }
15655                                                               else
15656                                                                 {
15657                                                                   /* 33222222222211111111110000000000
15658                                                                      10987654321098765432109876543210
15659                                                                      011001x1xx001100101xxxxxxxxxxxxx
15660                                                                      frecpx.  */
15661                                                                   return 1477;
15662                                                                 }
15663                                                             }
15664                                                           else
15665                                                             {
15666                                                               if (((word >> 22) & 0x1) == 0)
15667                                                                 {
15668                                                                   if (((word >> 23) & 0x1) == 0)
15669                                                                     {
15670                                                                       /* 33222222222211111111110000000000
15671                                                                          10987654321098765432109876543210
15672                                                                          011001x100001x10101xxxxxxxxxxxxx
15673                                                                          fcvtx.  */
15674                                                                       return 2087;
15675                                                                     }
15676                                                                   else
15677                                                                     {
15678                                                                       /* 33222222222211111111110000000000
15679                                                                          10987654321098765432109876543210
15680                                                                          011001x110001x10101xxxxxxxxxxxxx
15681                                                                          bfcvt.  */
15682                                                                       return 2499;
15683                                                                     }
15684                                                                 }
15685                                                               else
15686                                                                 {
15687                                                                   /* 33222222222211111111110000000000
15688                                                                      10987654321098765432109876543210
15689                                                                      011001x1x1001x10101xxxxxxxxxxxxx
15690                                                                      fcvt.  */
15691                                                                   return 1421;
15692                                                                 }
15693                                                             }
15694                                                         }
15695                                                       else
15696                                                         {
15697                                                           if (((word >> 22) & 0x1) == 0)
15698                                                             {
15699                                                               if (((word >> 23) & 0x1) == 0)
15700                                                                 {
15701                                                                   /* 33222222222211111111110000000000
15702                                                                      10987654321098765432109876543210
15703                                                                      011001x100011xx0101xxxxxxxxxxxxx
15704                                                                      flogb.  */
15705                                                                   return 2089;
15706                                                                 }
15707                                                               else
15708                                                                 {
15709                                                                   /* 33222222222211111111110000000000
15710                                                                      10987654321098765432109876543210
15711                                                                      011001x110011xx0101xxxxxxxxxxxxx
15712                                                                      fcvtzs.  */
15713                                                                   return 1426;
15714                                                                 }
15715                                                             }
15716                                                           else
15717                                                             {
15718                                                               if (((word >> 17) & 0x1) == 0)
15719                                                                 {
15720                                                                   if (((word >> 18) & 0x1) == 0)
15721                                                                     {
15722                                                                       /* 33222222222211111111110000000000
15723                                                                          10987654321098765432109876543210
15724                                                                          011001x1x1011000101xxxxxxxxxxxxx
15725                                                                          fcvtzs.  */
15726                                                                       return 1427;
15727                                                                     }
15728                                                                   else
15729                                                                     {
15730                                                                       if (((word >> 23) & 0x1) == 0)
15731                                                                         {
15732                                                                           /* 33222222222211111111110000000000
15733                                                                              10987654321098765432109876543210
15734                                                                              011001x101011100101xxxxxxxxxxxxx
15735                                                                              fcvtzs.  */
15736                                                                           return 1424;
15737                                                                         }
15738                                                                       else
15739                                                                         {
15740                                                                           /* 33222222222211111111110000000000
15741                                                                              10987654321098765432109876543210
15742                                                                              011001x111011100101xxxxxxxxxxxxx
15743                                                                              fcvtzs.  */
15744                                                                           return 1428;
15745                                                                         }
15746                                                                     }
15747                                                                 }
15748                                                               else
15749                                                                 {
15750                                                                   if (((word >> 18) & 0x1) == 0)
15751                                                                     {
15752                                                                       /* 33222222222211111111110000000000
15753                                                                          10987654321098765432109876543210
15754                                                                          011001x1x1011010101xxxxxxxxxxxxx
15755                                                                          fcvtzs.  */
15756                                                                       return 1423;
15757                                                                     }
15758                                                                   else
15759                                                                     {
15760                                                                       if (((word >> 23) & 0x1) == 0)
15761                                                                         {
15762                                                                           /* 33222222222211111111110000000000
15763                                                                              10987654321098765432109876543210
15764                                                                              011001x101011110101xxxxxxxxxxxxx
15765                                                                              fcvtzs.  */
15766                                                                           return 1425;
15767                                                                         }
15768                                                                       else
15769                                                                         {
15770                                                                           /* 33222222222211111111110000000000
15771                                                                              10987654321098765432109876543210
15772                                                                              011001x111011110101xxxxxxxxxxxxx
15773                                                                              fcvtzs.  */
15774                                                                           return 1429;
15775                                                                         }
15776                                                                     }
15777                                                                 }
15778                                                             }
15779                                                         }
15780                                                     }
15781                                                 }
15782                                               else
15783                                                 {
15784                                                   if (((word >> 17) & 0x1) == 0)
15785                                                     {
15786                                                       if (((word >> 18) & 0x1) == 0)
15787                                                         {
15788                                                           if (((word >> 19) & 0x1) == 0)
15789                                                             {
15790                                                               if (((word >> 20) & 0x1) == 0)
15791                                                                 {
15792                                                                   /* 33222222222211111111110000000000
15793                                                                      10987654321098765432109876543210
15794                                                                      011001x1xx000001101xxxxxxxxxxxxx
15795                                                                      frintp.  */
15796                                                                   return 1482;
15797                                                                 }
15798                                                               else
15799                                                                 {
15800                                                                   /* 33222222222211111111110000000000
15801                                                                      10987654321098765432109876543210
15802                                                                      011001x1xx010001101xxxxxxxxxxxxx
15803                                                                      ucvtf.  */
15804                                                                   return 1979;
15805                                                                 }
15806                                                             }
15807                                                           else
15808                                                             {
15809                                                               if (((word >> 20) & 0x1) == 0)
15810                                                                 {
15811                                                                   if (((word >> 22) & 0x1) == 0)
15812                                                                     {
15813                                                                       /* 33222222222211111111110000000000
15814                                                                          10987654321098765432109876543210
15815                                                                          011001x1x0001001101xxxxxxxxxxxxx
15816                                                                          fcvt.  */
15817                                                                       return 1418;
15818                                                                     }
15819                                                                   else
15820                                                                     {
15821                                                                       /* 33222222222211111111110000000000
15822                                                                          10987654321098765432109876543210
15823                                                                          011001x1x1001001101xxxxxxxxxxxxx
15824                                                                          fcvt.  */
15825                                                                       return 1420;
15826                                                                     }
15827                                                                 }
15828                                                               else
15829                                                                 {
15830                                                                   /* 33222222222211111111110000000000
15831                                                                      10987654321098765432109876543210
15832                                                                      011001x1xx011001101xxxxxxxxxxxxx
15833                                                                      fcvtzu.  */
15834                                                                   return 1434;
15835                                                                 }
15836                                                             }
15837                                                         }
15838                                                       else
15839                                                         {
15840                                                           if (((word >> 19) & 0x1) == 0)
15841                                                             {
15842                                                               if (((word >> 22) & 0x1) == 0)
15843                                                                 {
15844                                                                   /* 33222222222211111111110000000000
15845                                                                      10987654321098765432109876543210
15846                                                                      011001x1x00x0101101xxxxxxxxxxxxx
15847                                                                      ucvtf.  */
15848                                                                   return 1978;
15849                                                                 }
15850                                                               else
15851                                                                 {
15852                                                                   if (((word >> 23) & 0x1) == 0)
15853                                                                     {
15854                                                                       /* 33222222222211111111110000000000
15855                                                                          10987654321098765432109876543210
15856                                                                          011001x1010x0101101xxxxxxxxxxxxx
15857                                                                          ucvtf.  */
15858                                                                       return 1977;
15859                                                                     }
15860                                                                   else
15861                                                                     {
15862                                                                       /* 33222222222211111111110000000000
15863                                                                          10987654321098765432109876543210
15864                                                                          011001x1110x0101101xxxxxxxxxxxxx
15865                                                                          ucvtf.  */
15866                                                                       return 1981;
15867                                                                     }
15868                                                                 }
15869                                                             }
15870                                                           else
15871                                                             {
15872                                                               if (((word >> 20) & 0x1) == 0)
15873                                                                 {
15874                                                                   /* 33222222222211111111110000000000
15875                                                                      10987654321098765432109876543210
15876                                                                      011001x1xx001101101xxxxxxxxxxxxx
15877                                                                      fsqrt.  */
15878                                                                   return 1488;
15879                                                                 }
15880                                                               else
15881                                                                 {
15882                                                                   if (((word >> 22) & 0x1) == 0)
15883                                                                     {
15884                                                                       /* 33222222222211111111110000000000
15885                                                                          10987654321098765432109876543210
15886                                                                          011001x1x0011101101xxxxxxxxxxxxx
15887                                                                          fcvtzu.  */
15888                                                                       return 1433;
15889                                                                     }
15890                                                                   else
15891                                                                     {
15892                                                                       if (((word >> 23) & 0x1) == 0)
15893                                                                         {
15894                                                                           /* 33222222222211111111110000000000
15895                                                                              10987654321098765432109876543210
15896                                                                              011001x101011101101xxxxxxxxxxxxx
15897                                                                              fcvtzu.  */
15898                                                                           return 1431;
15899                                                                         }
15900                                                                       else
15901                                                                         {
15902                                                                           /* 33222222222211111111110000000000
15903                                                                              10987654321098765432109876543210
15904                                                                              011001x111011101101xxxxxxxxxxxxx
15905                                                                              fcvtzu.  */
15906                                                                           return 1435;
15907                                                                         }
15908                                                                     }
15909                                                                 }
15910                                                             }
15911                                                         }
15912                                                     }
15913                                                   else
15914                                                     {
15915                                                       if (((word >> 18) & 0x1) == 0)
15916                                                         {
15917                                                           if (((word >> 19) & 0x1) == 0)
15918                                                             {
15919                                                               if (((word >> 20) & 0x1) == 0)
15920                                                                 {
15921                                                                   /* 33222222222211111111110000000000
15922                                                                      10987654321098765432109876543210
15923                                                                      011001x1xx000011101xxxxxxxxxxxxx
15924                                                                      frintz.  */
15925                                                                   return 1484;
15926                                                                 }
15927                                                               else
15928                                                                 {
15929                                                                   /* 33222222222211111111110000000000
15930                                                                      10987654321098765432109876543210
15931                                                                      011001x1xx010011101xxxxxxxxxxxxx
15932                                                                      ucvtf.  */
15933                                                                   return 1976;
15934                                                                 }
15935                                                             }
15936                                                           else
15937                                                             {
15938                                                               if (((word >> 20) & 0x1) == 0)
15939                                                                 {
15940                                                                   /* 33222222222211111111110000000000
15941                                                                      10987654321098765432109876543210
15942                                                                      011001x1xx001011101xxxxxxxxxxxxx
15943                                                                      fcvt.  */
15944                                                                   return 1422;
15945                                                                 }
15946                                                               else
15947                                                                 {
15948                                                                   /* 33222222222211111111110000000000
15949                                                                      10987654321098765432109876543210
15950                                                                      011001x1xx011011101xxxxxxxxxxxxx
15951                                                                      fcvtzu.  */
15952                                                                   return 1430;
15953                                                                 }
15954                                                             }
15955                                                         }
15956                                                       else
15957                                                         {
15958                                                           if (((word >> 19) & 0x1) == 0)
15959                                                             {
15960                                                               if (((word >> 20) & 0x1) == 0)
15961                                                                 {
15962                                                                   /* 33222222222211111111110000000000
15963                                                                      10987654321098765432109876543210
15964                                                                      011001x1xx000111101xxxxxxxxxxxxx
15965                                                                      frinti.  */
15966                                                                   return 1479;
15967                                                                 }
15968                                                               else
15969                                                                 {
15970                                                                   if (((word >> 23) & 0x1) == 0)
15971                                                                     {
15972                                                                       /* 33222222222211111111110000000000
15973                                                                          10987654321098765432109876543210
15974                                                                          011001x10x010111101xxxxxxxxxxxxx
15975                                                                          ucvtf.  */
15976                                                                       return 1980;
15977                                                                     }
15978                                                                   else
15979                                                                     {
15980                                                                       /* 33222222222211111111110000000000
15981                                                                          10987654321098765432109876543210
15982                                                                          011001x11x010111101xxxxxxxxxxxxx
15983                                                                          ucvtf.  */
15984                                                                       return 1982;
15985                                                                     }
15986                                                                 }
15987                                                             }
15988                                                           else
15989                                                             {
15990                                                               if (((word >> 23) & 0x1) == 0)
15991                                                                 {
15992                                                                   /* 33222222222211111111110000000000
15993                                                                      10987654321098765432109876543210
15994                                                                      011001x10x0x1111101xxxxxxxxxxxxx
15995                                                                      fcvtzu.  */
15996                                                                   return 1432;
15997                                                                 }
15998                                                               else
15999                                                                 {
16000                                                                   /* 33222222222211111111110000000000
16001                                                                      10987654321098765432109876543210
16002                                                                      011001x11x0x1111101xxxxxxxxxxxxx
16003                                                                      fcvtzu.  */
16004                                                                   return 1436;
16005                                                                 }
16006                                                             }
16007                                                         }
16008                                                     }
16009                                                 }
16010                                             }
16011                                           else
16012                                             {
16013                                               if (((word >> 22) & 0x1) == 0)
16014                                                 {
16015                                                   if (((word >> 23) & 0x1) == 0)
16016                                                     {
16017                                                       /* 33222222222211111111110000000000
16018                                                          10987654321098765432109876543210
16019                                                          111001x1000xxxxx101xxxxxxxxxxxxx
16020                                                          st1w.  */
16021                                                       return 1914;
16022                                                     }
16023                                                   else
16024                                                     {
16025                                                       /* 33222222222211111111110000000000
16026                                                          10987654321098765432109876543210
16027                                                          111001x1100xxxxx101xxxxxxxxxxxxx
16028                                                          st1d.  */
16029                                                       return 1893;
16030                                                     }
16031                                                 }
16032                                               else
16033                                                 {
16034                                                   if (((word >> 23) & 0x1) == 0)
16035                                                     {
16036                                                       /* 33222222222211111111110000000000
16037                                                          10987654321098765432109876543210
16038                                                          111001x1010xxxxx101xxxxxxxxxxxxx
16039                                                          st1w.  */
16040                                                       return 1921;
16041                                                     }
16042                                                   else
16043                                                     {
16044                                                       /* 33222222222211111111110000000000
16045                                                          10987654321098765432109876543210
16046                                                          111001x1110xxxxx101xxxxxxxxxxxxx
16047                                                          st1d.  */
16048                                                       return 1897;
16049                                                     }
16050                                                 }
16051                                             }
16052                                         }
16053                                       else
16054                                         {
16055                                           if (((word >> 31) & 0x1) == 0)
16056                                             {
16057                                               /* 33222222222211111111110000000000
16058                                                  10987654321098765432109876543210
16059                                                  011001x1xx0xxxxx111xxxxxxxxxxxxx
16060                                                  facgt.  */
16061                                               return 1395;
16062                                             }
16063                                           else
16064                                             {
16065                                               if (((word >> 20) & 0x1) == 0)
16066                                                 {
16067                                                   /* 33222222222211111111110000000000
16068                                                      10987654321098765432109876543210
16069                                                      111001x1xx00xxxx111xxxxxxxxxxxxx
16070                                                      st1w.  */
16071                                                   return 1922;
16072                                                 }
16073                                               else
16074                                                 {
16075                                                   if (((word >> 22) & 0x1) == 0)
16076                                                     {
16077                                                       if (((word >> 23) & 0x1) == 0)
16078                                                         {
16079                                                           /* 33222222222211111111110000000000
16080                                                              10987654321098765432109876543210
16081                                                              111001x10001xxxx111xxxxxxxxxxxxx
16082                                                              stnt1w.  */
16083                                                           return 1956;
16084                                                         }
16085                                                       else
16086                                                         {
16087                                                           /* 33222222222211111111110000000000
16088                                                              10987654321098765432109876543210
16089                                                              111001x11001xxxx111xxxxxxxxxxxxx
16090                                                              stnt1d.  */
16091                                                           return 1952;
16092                                                         }
16093                                                     }
16094                                                   else
16095                                                     {
16096                                                       if (((word >> 23) & 0x1) == 0)
16097                                                         {
16098                                                           /* 33222222222211111111110000000000
16099                                                              10987654321098765432109876543210
16100                                                              111001x10101xxxx111xxxxxxxxxxxxx
16101                                                              st3w.  */
16102                                                           return 1940;
16103                                                         }
16104                                                       else
16105                                                         {
16106                                                           /* 33222222222211111111110000000000
16107                                                              10987654321098765432109876543210
16108                                                              111001x11101xxxx111xxxxxxxxxxxxx
16109                                                              st3d.  */
16110                                                           return 1936;
16111                                                         }
16112                                                     }
16113                                                 }
16114                                             }
16115                                         }
16116                                     }
16117                                 }
16118                             }
16119                           else
16120                             {
16121                               if (((word >> 30) & 0x1) == 0)
16122                                 {
16123                                   if (((word >> 14) & 0x1) == 0)
16124                                     {
16125                                       if (((word >> 20) & 0x1) == 0)
16126                                         {
16127                                           if (((word >> 31) & 0x1) == 0)
16128                                             {
16129                                               if (((word >> 16) & 0x1) == 0)
16130                                                 {
16131                                                   if (((word >> 17) & 0x1) == 0)
16132                                                     {
16133                                                       if (((word >> 18) & 0x1) == 0)
16134                                                         {
16135                                                           if (((word >> 19) & 0x1) == 0)
16136                                                             {
16137                                                               /* 33222222222211111111110000000000
16138                                                                  10987654321098765432109876543210
16139                                                                  001001x1xx10000010xxxxxxxxxxxxxx
16140                                                                  cntp.  */
16141                                                               return 1364;
16142                                                             }
16143                                                           else
16144                                                             {
16145                                                               if (((word >> 10) & 0x1) == 0)
16146                                                                 {
16147                                                                   if (((word >> 11) & 0x1) == 0)
16148                                                                     {
16149                                                                       if (((word >> 12) & 0x1) == 0)
16150                                                                         {
16151                                                                           /* 33222222222211111111110000000000
16152                                                                              10987654321098765432109876543210
16153                                                                              001001x1xx10100010x000xxxxxxxxxx
16154                                                                              sqincp.  */
16155                                                                           return 1871;
16156                                                                         }
16157                                                                       else
16158                                                                         {
16159                                                                           /* 33222222222211111111110000000000
16160                                                                              10987654321098765432109876543210
16161                                                                              001001x1xx10100010x100xxxxxxxxxx
16162                                                                              wrffr.  */
16163                                                                           return 2044;
16164                                                                         }
16165                                                                     }
16166                                                                   else
16167                                                                     {
16168                                                                       /* 33222222222211111111110000000000
16169                                                                          10987654321098765432109876543210
16170                                                                          001001x1xx10100010xx10xxxxxxxxxx
16171                                                                          sqincp.  */
16172                                                                       return 1873;
16173                                                                     }
16174                                                                 }
16175                                                               else
16176                                                                 {
16177                                                                   /* 33222222222211111111110000000000
16178                                                                      10987654321098765432109876543210
16179                                                                      001001x1xx10100010xxx1xxxxxxxxxx
16180                                                                      sqincp.  */
16181                                                                   return 1872;
16182                                                                 }
16183                                                             }
16184                                                         }
16185                                                       else
16186                                                         {
16187                                                           if (((word >> 11) & 0x1) == 0)
16188                                                             {
16189                                                               if (((word >> 12) & 0x1) == 0)
16190                                                                 {
16191                                                                   /* 33222222222211111111110000000000
16192                                                                      10987654321098765432109876543210
16193                                                                      001001x1xx10x10010x00xxxxxxxxxxx
16194                                                                      incp.  */
16195                                                                   return 1502;
16196                                                                 }
16197                                                               else
16198                                                                 {
16199                                                                   /* 33222222222211111111110000000000
16200                                                                      10987654321098765432109876543210
16201                                                                      001001x1xx10x10010x10xxxxxxxxxxx
16202                                                                      setffr.  */
16203                                                                   return 1838;
16204                                                                 }
16205                                                             }
16206                                                           else
16207                                                             {
16208                                                               /* 33222222222211111111110000000000
16209                                                                  10987654321098765432109876543210
16210                                                                  001001x1xx10x10010xx1xxxxxxxxxxx
16211                                                                  incp.  */
16212                                                               return 1503;
16213                                                             }
16214                                                         }
16215                                                     }
16216                                                   else
16217                                                     {
16218                                                       if (((word >> 10) & 0x1) == 0)
16219                                                         {
16220                                                           if (((word >> 11) & 0x1) == 0)
16221                                                             {
16222                                                               /* 33222222222211111111110000000000
16223                                                                  10987654321098765432109876543210
16224                                                                  001001x1xx10xx1010xx00xxxxxxxxxx
16225                                                                  sqdecp.  */
16226                                                               return 1857;
16227                                                             }
16228                                                           else
16229                                                             {
16230                                                               /* 33222222222211111111110000000000
16231                                                                  10987654321098765432109876543210
16232                                                                  001001x1xx10xx1010xx10xxxxxxxxxx
16233                                                                  sqdecp.  */
16234                                                               return 1859;
16235                                                             }
16236                                                         }
16237                                                       else
16238                                                         {
16239                                                           /* 33222222222211111111110000000000
16240                                                              10987654321098765432109876543210
16241                                                              001001x1xx10xx1010xxx1xxxxxxxxxx
16242                                                              sqdecp.  */
16243                                                           return 1858;
16244                                                         }
16245                                                     }
16246                                                 }
16247                                               else
16248                                                 {
16249                                                   if (((word >> 10) & 0x1) == 0)
16250                                                     {
16251                                                       if (((word >> 11) & 0x1) == 0)
16252                                                         {
16253                                                           if (((word >> 17) & 0x1) == 0)
16254                                                             {
16255                                                               if (((word >> 18) & 0x1) == 0)
16256                                                                 {
16257                                                                   /* 33222222222211111111110000000000
16258                                                                      10987654321098765432109876543210
16259                                                                      001001x1xx10x00110xx00xxxxxxxxxx
16260                                                                      uqincp.  */
16261                                                                   return 2019;
16262                                                                 }
16263                                                               else
16264                                                                 {
16265                                                                   /* 33222222222211111111110000000000
16266                                                                      10987654321098765432109876543210
16267                                                                      001001x1xx10x10110xx00xxxxxxxxxx
16268                                                                      decp.  */
16269                                                                   return 1377;
16270                                                                 }
16271                                                             }
16272                                                           else
16273                                                             {
16274                                                               /* 33222222222211111111110000000000
16275                                                                  10987654321098765432109876543210
16276                                                                  001001x1xx10xx1110xx00xxxxxxxxxx
16277                                                                  uqdecp.  */
16278                                                               return 2005;
16279                                                             }
16280                                                         }
16281                                                       else
16282                                                         {
16283                                                           if (((word >> 17) & 0x1) == 0)
16284                                                             {
16285                                                               if (((word >> 18) & 0x1) == 0)
16286                                                                 {
16287                                                                   /* 33222222222211111111110000000000
16288                                                                      10987654321098765432109876543210
16289                                                                      001001x1xx10x00110xx10xxxxxxxxxx
16290                                                                      uqincp.  */
16291                                                                   return 2020;
16292                                                                 }
16293                                                               else
16294                                                                 {
16295                                                                   /* 33222222222211111111110000000000
16296                                                                      10987654321098765432109876543210
16297                                                                      001001x1xx10x10110xx10xxxxxxxxxx
16298                                                                      decp.  */
16299                                                                   return 1378;
16300                                                                 }
16301                                                             }
16302                                                           else
16303                                                             {
16304                                                               /* 33222222222211111111110000000000
16305                                                                  10987654321098765432109876543210
16306                                                                  001001x1xx10xx1110xx10xxxxxxxxxx
16307                                                                  uqdecp.  */
16308                                                               return 2006;
16309                                                             }
16310                                                         }
16311                                                     }
16312                                                   else
16313                                                     {
16314                                                       if (((word >> 17) & 0x1) == 0)
16315                                                         {
16316                                                           /* 33222222222211111111110000000000
16317                                                              10987654321098765432109876543210
16318                                                              001001x1xx10xx0110xxx1xxxxxxxxxx
16319                                                              uqincp.  */
16320                                                           return 2021;
16321                                                         }
16322                                                       else
16323                                                         {
16324                                                           /* 33222222222211111111110000000000
16325                                                              10987654321098765432109876543210
16326                                                              001001x1xx10xx1110xxx1xxxxxxxxxx
16327                                                              uqdecp.  */
16328                                                           return 2007;
16329                                                         }
16330                                                     }
16331                                                 }
16332                                             }
16333                                           else
16334                                             {
16335                                               if (((word >> 22) & 0x1) == 0)
16336                                                 {
16337                                                   if (((word >> 23) & 0x1) == 0)
16338                                                     {
16339                                                       /* 33222222222211111111110000000000
16340                                                          10987654321098765432109876543210
16341                                                          101001x10010xxxx10xxxxxxxxxxxxxx
16342                                                          ld1sh.  */
16343                                                       return 1595;
16344                                                     }
16345                                                   else
16346                                                     {
16347                                                       /* 33222222222211111111110000000000
16348                                                          10987654321098765432109876543210
16349                                                          101001x11010xxxx10xxxxxxxxxxxxxx
16350                                                          ld1sb.  */
16351                                                       return 1582;
16352                                                     }
16353                                                 }
16354                                               else
16355                                                 {
16356                                                   if (((word >> 23) & 0x1) == 0)
16357                                                     {
16358                                                       /* 33222222222211111111110000000000
16359                                                          10987654321098765432109876543210
16360                                                          101001x10110xxxx10xxxxxxxxxxxxxx
16361                                                          ld1w.  */
16362                                                       return 1614;
16363                                                     }
16364                                                   else
16365                                                     {
16366                                                       /* 33222222222211111111110000000000
16367                                                          10987654321098765432109876543210
16368                                                          101001x11110xxxx10xxxxxxxxxxxxxx
16369                                                          ld1d.  */
16370                                                       return 1534;
16371                                                     }
16372                                                 }
16373                                             }
16374                                         }
16375                                       else
16376                                         {
16377                                           if (((word >> 22) & 0x1) == 0)
16378                                             {
16379                                               if (((word >> 23) & 0x1) == 0)
16380                                                 {
16381                                                   /* 33222222222211111111110000000000
16382                                                      10987654321098765432109876543210
16383                                                      x01001x10011xxxx10xxxxxxxxxxxxxx
16384                                                      ldnf1sh.  */
16385                                                   return 1728;
16386                                                 }
16387                                               else
16388                                                 {
16389                                                   /* 33222222222211111111110000000000
16390                                                      10987654321098765432109876543210
16391                                                      x01001x11011xxxx10xxxxxxxxxxxxxx
16392                                                      ldnf1sb.  */
16393                                                   return 1725;
16394                                                 }
16395                                             }
16396                                           else
16397                                             {
16398                                               if (((word >> 23) & 0x1) == 0)
16399                                                 {
16400                                                   /* 33222222222211111111110000000000
16401                                                      10987654321098765432109876543210
16402                                                      x01001x10111xxxx10xxxxxxxxxxxxxx
16403                                                      ldnf1w.  */
16404                                                   return 1731;
16405                                                 }
16406                                               else
16407                                                 {
16408                                                   /* 33222222222211111111110000000000
16409                                                      10987654321098765432109876543210
16410                                                      x01001x11111xxxx10xxxxxxxxxxxxxx
16411                                                      ldnf1d.  */
16412                                                   return 1720;
16413                                                 }
16414                                             }
16415                                         }
16416                                     }
16417                                   else
16418                                     {
16419                                       if (((word >> 31) & 0x1) == 0)
16420                                         {
16421                                           if (((word >> 16) & 0x1) == 0)
16422                                             {
16423                                               if (((word >> 17) & 0x1) == 0)
16424                                                 {
16425                                                   if (((word >> 18) & 0x1) == 0)
16426                                                     {
16427                                                       if (((word >> 19) & 0x1) == 0)
16428                                                         {
16429                                                           if (((word >> 20) & 0x1) == 0)
16430                                                             {
16431                                                               /* 33222222222211111111110000000000
16432                                                                  10987654321098765432109876543210
16433                                                                  001001x1xx10000011xxxxxxxxxxxxxx
16434                                                                  add.  */
16435                                                               return 1291;
16436                                                             }
16437                                                           else
16438                                                             {
16439                                                               /* 33222222222211111111110000000000
16440                                                                  10987654321098765432109876543210
16441                                                                  001001x1xx11000011xxxxxxxxxxxxxx
16442                                                                  mul.  */
16443                                                               return 1760;
16444                                                             }
16445                                                         }
16446                                                       else
16447                                                         {
16448                                                           if (((word >> 20) & 0x1) == 0)
16449                                                             {
16450                                                               /* 33222222222211111111110000000000
16451                                                                  10987654321098765432109876543210
16452                                                                  001001x1xx10100011xxxxxxxxxxxxxx
16453                                                                  smax.  */
16454                                                               return 1839;
16455                                                             }
16456                                                           else
16457                                                             {
16458                                                               /* 33222222222211111111110000000000
16459                                                                  10987654321098765432109876543210
16460                                                                  001001x1xx11100011xxxxxxxxxxxxxx
16461                                                                  dup.  */
16462                                                               return 1383;
16463                                                             }
16464                                                         }
16465                                                     }
16466                                                   else
16467                                                     {
16468                                                       /* 33222222222211111111110000000000
16469                                                          10987654321098765432109876543210
16470                                                          001001x1xx1xx10011xxxxxxxxxxxxxx
16471                                                          sqadd.  */
16472                                                       return 1848;
16473                                                     }
16474                                                 }
16475                                               else
16476                                                 {
16477                                                   if (((word >> 18) & 0x1) == 0)
16478                                                     {
16479                                                       /* 33222222222211111111110000000000
16480                                                          10987654321098765432109876543210
16481                                                          001001x1xx1xx01011xxxxxxxxxxxxxx
16482                                                          smin.  */
16483                                                       return 1842;
16484                                                     }
16485                                                   else
16486                                                     {
16487                                                       /* 33222222222211111111110000000000
16488                                                          10987654321098765432109876543210
16489                                                          001001x1xx1xx11011xxxxxxxxxxxxxx
16490                                                          sqsub.  */
16491                                                       return 1878;
16492                                                     }
16493                                                 }
16494                                             }
16495                                           else
16496                                             {
16497                                               if (((word >> 17) & 0x1) == 0)
16498                                                 {
16499                                                   if (((word >> 18) & 0x1) == 0)
16500                                                     {
16501                                                       if (((word >> 19) & 0x1) == 0)
16502                                                         {
16503                                                           /* 33222222222211111111110000000000
16504                                                              10987654321098765432109876543210
16505                                                              001001x1xx1x000111xxxxxxxxxxxxxx
16506                                                              sub.  */
16507                                                           return 1960;
16508                                                         }
16509                                                       else
16510                                                         {
16511                                                           if (((word >> 20) & 0x1) == 0)
16512                                                             {
16513                                                               /* 33222222222211111111110000000000
16514                                                                  10987654321098765432109876543210
16515                                                                  001001x1xx10100111xxxxxxxxxxxxxx
16516                                                                  umax.  */
16517                                                               return 1988;
16518                                                             }
16519                                                           else
16520                                                             {
16521                                                               /* 33222222222211111111110000000000
16522                                                                  10987654321098765432109876543210
16523                                                                  001001x1xx11100111xxxxxxxxxxxxxx
16524                                                                  fdup.  */
16525                                                               return 1439;
16526                                                             }
16527                                                         }
16528                                                     }
16529                                                   else
16530                                                     {
16531                                                       /* 33222222222211111111110000000000
16532                                                          10987654321098765432109876543210
16533                                                          001001x1xx1xx10111xxxxxxxxxxxxxx
16534                                                          uqadd.  */
16535                                                       return 1996;
16536                                                     }
16537                                                 }
16538                                               else
16539                                                 {
16540                                                   if (((word >> 18) & 0x1) == 0)
16541                                                     {
16542                                                       if (((word >> 19) & 0x1) == 0)
16543                                                         {
16544                                                           /* 33222222222211111111110000000000
16545                                                              10987654321098765432109876543210
16546                                                              001001x1xx1x001111xxxxxxxxxxxxxx
16547                                                              subr.  */
16548                                                           return 1962;
16549                                                         }
16550                                                       else
16551                                                         {
16552                                                           /* 33222222222211111111110000000000
16553                                                              10987654321098765432109876543210
16554                                                              001001x1xx1x101111xxxxxxxxxxxxxx
16555                                                              umin.  */
16556                                                           return 1991;
16557                                                         }
16558                                                     }
16559                                                   else
16560                                                     {
16561                                                       /* 33222222222211111111110000000000
16562                                                          10987654321098765432109876543210
16563                                                          001001x1xx1xx11111xxxxxxxxxxxxxx
16564                                                          uqsub.  */
16565                                                       return 2026;
16566                                                     }
16567                                                 }
16568                                             }
16569                                         }
16570                                       else
16571                                         {
16572                                           if (((word >> 13) & 0x1) == 0)
16573                                             {
16574                                               if (((word >> 22) & 0x1) == 0)
16575                                                 {
16576                                                   if (((word >> 23) & 0x1) == 0)
16577                                                     {
16578                                                       /* 33222222222211111111110000000000
16579                                                          10987654321098765432109876543210
16580                                                          101001x1001xxxxx110xxxxxxxxxxxxx
16581                                                          ld2w.  */
16582                                                       return 1622;
16583                                                     }
16584                                                   else
16585                                                     {
16586                                                       /* 33222222222211111111110000000000
16587                                                          10987654321098765432109876543210
16588                                                          101001x1101xxxxx110xxxxxxxxxxxxx
16589                                                          ld2d.  */
16590                                                       return 1618;
16591                                                     }
16592                                                 }
16593                                               else
16594                                                 {
16595                                                   if (((word >> 23) & 0x1) == 0)
16596                                                     {
16597                                                       /* 33222222222211111111110000000000
16598                                                          10987654321098765432109876543210
16599                                                          101001x1011xxxxx110xxxxxxxxxxxxx
16600                                                          ld4w.  */
16601                                                       return 1638;
16602                                                     }
16603                                                   else
16604                                                     {
16605                                                       /* 33222222222211111111110000000000
16606                                                          10987654321098765432109876543210
16607                                                          101001x1111xxxxx110xxxxxxxxxxxxx
16608                                                          ld4d.  */
16609                                                       return 1634;
16610                                                     }
16611                                                 }
16612                                             }
16613                                           else
16614                                             {
16615                                               if (((word >> 22) & 0x1) == 0)
16616                                                 {
16617                                                   if (((word >> 23) & 0x1) == 0)
16618                                                     {
16619                                                       /* 33222222222211111111110000000000
16620                                                          10987654321098765432109876543210
16621                                                          101001x1001xxxxx111xxxxxxxxxxxxx
16622                                                          ld2w.  */
16623                                                       return 1623;
16624                                                     }
16625                                                   else
16626                                                     {
16627                                                       /* 33222222222211111111110000000000
16628                                                          10987654321098765432109876543210
16629                                                          101001x1101xxxxx111xxxxxxxxxxxxx
16630                                                          ld2d.  */
16631                                                       return 1619;
16632                                                     }
16633                                                 }
16634                                               else
16635                                                 {
16636                                                   if (((word >> 23) & 0x1) == 0)
16637                                                     {
16638                                                       /* 33222222222211111111110000000000
16639                                                          10987654321098765432109876543210
16640                                                          101001x1011xxxxx111xxxxxxxxxxxxx
16641                                                          ld4w.  */
16642                                                       return 1639;
16643                                                     }
16644                                                   else
16645                                                     {
16646                                                       /* 33222222222211111111110000000000
16647                                                          10987654321098765432109876543210
16648                                                          101001x1111xxxxx111xxxxxxxxxxxxx
16649                                                          ld4d.  */
16650                                                       return 1635;
16651                                                     }
16652                                                 }
16653                                             }
16654                                         }
16655                                     }
16656                                 }
16657                               else
16658                                 {
16659                                   if (((word >> 13) & 0x1) == 0)
16660                                     {
16661                                       if (((word >> 31) & 0x1) == 0)
16662                                         {
16663                                           if (((word >> 14) & 0x1) == 0)
16664                                             {
16665                                               /* 33222222222211111111110000000000
16666                                                  10987654321098765432109876543210
16667                                                  011001x1xx1xxxxx100xxxxxxxxxxxxx
16668                                                  fmad.  */
16669                                               return 1441;
16670                                             }
16671                                           else
16672                                             {
16673                                               /* 33222222222211111111110000000000
16674                                                  10987654321098765432109876543210
16675                                                  011001x1xx1xxxxx110xxxxxxxxxxxxx
16676                                                  fnmad.  */
16677                                               return 1471;
16678                                             }
16679                                         }
16680                                       else
16681                                         {
16682                                           if (((word >> 22) & 0x1) == 0)
16683                                             {
16684                                               if (((word >> 23) & 0x1) == 0)
16685                                                 {
16686                                                   /* 33222222222211111111110000000000
16687                                                      10987654321098765432109876543210
16688                                                      111001x1001xxxxx1x0xxxxxxxxxxxxx
16689                                                      st1w.  */
16690                                                   return 1915;
16691                                                 }
16692                                               else
16693                                                 {
16694                                                   /* 33222222222211111111110000000000
16695                                                      10987654321098765432109876543210
16696                                                      111001x1101xxxxx1x0xxxxxxxxxxxxx
16697                                                      st1d.  */
16698                                                   return 1894;
16699                                                 }
16700                                             }
16701                                           else
16702                                             {
16703                                               /* 33222222222211111111110000000000
16704                                                  10987654321098765432109876543210
16705                                                  111001x1x11xxxxx1x0xxxxxxxxxxxxx
16706                                                  st1w.  */
16707                                               return 1920;
16708                                             }
16709                                         }
16710                                     }
16711                                   else
16712                                     {
16713                                       if (((word >> 14) & 0x1) == 0)
16714                                         {
16715                                           if (((word >> 31) & 0x1) == 0)
16716                                             {
16717                                               /* 33222222222211111111110000000000
16718                                                  10987654321098765432109876543210
16719                                                  011001x1xx1xxxxx101xxxxxxxxxxxxx
16720                                                  fmsb.  */
16721                                               return 1462;
16722                                             }
16723                                           else
16724                                             {
16725                                               if (((word >> 22) & 0x1) == 0)
16726                                                 {
16727                                                   if (((word >> 23) & 0x1) == 0)
16728                                                     {
16729                                                       /* 33222222222211111111110000000000
16730                                                          10987654321098765432109876543210
16731                                                          111001x1001xxxxx101xxxxxxxxxxxxx
16732                                                          st1w.  */
16733                                                       return 1916;
16734                                                     }
16735                                                   else
16736                                                     {
16737                                                       /* 33222222222211111111110000000000
16738                                                          10987654321098765432109876543210
16739                                                          111001x1101xxxxx101xxxxxxxxxxxxx
16740                                                          st1d.  */
16741                                                       return 1895;
16742                                                     }
16743                                                 }
16744                                               else
16745                                                 {
16746                                                   /* 33222222222211111111110000000000
16747                                                      10987654321098765432109876543210
16748                                                      111001x1x11xxxxx101xxxxxxxxxxxxx
16749                                                      st1w.  */
16750                                                   return 1923;
16751                                                 }
16752                                             }
16753                                         }
16754                                       else
16755                                         {
16756                                           if (((word >> 31) & 0x1) == 0)
16757                                             {
16758                                               /* 33222222222211111111110000000000
16759                                                  10987654321098765432109876543210
16760                                                  011001x1xx1xxxxx111xxxxxxxxxxxxx
16761                                                  fnmsb.  */
16762                                               return 1474;
16763                                             }
16764                                           else
16765                                             {
16766                                               if (((word >> 20) & 0x1) == 0)
16767                                                 {
16768                                                   if (((word >> 23) & 0x1) == 0)
16769                                                     {
16770                                                       /* 33222222222211111111110000000000
16771                                                          10987654321098765432109876543210
16772                                                          111001x10x10xxxx111xxxxxxxxxxxxx
16773                                                          st1w.  */
16774                                                       return 1924;
16775                                                     }
16776                                                   else
16777                                                     {
16778                                                       /* 33222222222211111111110000000000
16779                                                          10987654321098765432109876543210
16780                                                          111001x11x10xxxx111xxxxxxxxxxxxx
16781                                                          st1d.  */
16782                                                       return 1898;
16783                                                     }
16784                                                 }
16785                                               else
16786                                                 {
16787                                                   if (((word >> 22) & 0x1) == 0)
16788                                                     {
16789                                                       if (((word >> 23) & 0x1) == 0)
16790                                                         {
16791                                                           /* 33222222222211111111110000000000
16792                                                              10987654321098765432109876543210
16793                                                              111001x10011xxxx111xxxxxxxxxxxxx
16794                                                              st2w.  */
16795                                                           return 1932;
16796                                                         }
16797                                                       else
16798                                                         {
16799                                                           /* 33222222222211111111110000000000
16800                                                              10987654321098765432109876543210
16801                                                              111001x11011xxxx111xxxxxxxxxxxxx
16802                                                              st2d.  */
16803                                                           return 1928;
16804                                                         }
16805                                                     }
16806                                                   else
16807                                                     {
16808                                                       if (((word >> 23) & 0x1) == 0)
16809                                                         {
16810                                                           /* 33222222222211111111110000000000
16811                                                              10987654321098765432109876543210
16812                                                              111001x10111xxxx111xxxxxxxxxxxxx
16813                                                              st4w.  */
16814                                                           return 1948;
16815                                                         }
16816                                                       else
16817                                                         {
16818                                                           /* 33222222222211111111110000000000
16819                                                              10987654321098765432109876543210
16820                                                              111001x11111xxxx111xxxxxxxxxxxxx
16821                                                              st4d.  */
16822                                                           return 1944;
16823                                                         }
16824                                                     }
16825                                                 }
16826                                             }
16827                                         }
16828                                     }
16829                                 }
16830                             }
16831                         }
16832                     }
16833                 }
16834             }
16835           else
16836             {
16837               if (((word >> 29) & 0x1) == 0)
16838                 {
16839                   if (((word >> 30) & 0x1) == 0)
16840                     {
16841                       if (((word >> 31) & 0x1) == 0)
16842                         {
16843                           /* 33222222222211111111110000000000
16844                              10987654321098765432109876543210
16845                              000101xxxxxxxxxxxxxxxxxxxxxxxxxx
16846                              b.  */
16847                           return 636;
16848                         }
16849                       else
16850                         {
16851                           /* 33222222222211111111110000000000
16852                              10987654321098765432109876543210
16853                              100101xxxxxxxxxxxxxxxxxxxxxxxxxx
16854                              bl.  */
16855                           return 637;
16856                         }
16857                     }
16858                   else
16859                     {
16860                       if (((word >> 24) & 0x1) == 0)
16861                         {
16862                           if (((word >> 4) & 0x1) == 0)
16863                             {
16864                               if (((word >> 25) & 0x1) == 0)
16865                                 {
16866                                   if (((word >> 31) & 0x1) == 0)
16867                                     {
16868                                       /* 33222222222211111111110000000000
16869                                          10987654321098765432109876543210
16870                                          01010100xxxxxxxxxxxxxxxxxxx0xxxx
16871                                          b.c.  */
16872                                       return 657;
16873                                     }
16874                                   else
16875                                     {
16876                                       if (((word >> 0) & 0x1) == 0)
16877                                         {
16878                                           if (((word >> 1) & 0x1) == 0)
16879                                             {
16880                                               if (((word >> 21) & 0x1) == 0)
16881                                                 {
16882                                                   /* 33222222222211111111110000000000
16883                                                      10987654321098765432109876543210
16884                                                      11010100xx0xxxxxxxxxxxxxxxx0xx00
16885                                                      hlt.  */
16886                                                   return 753;
16887                                                 }
16888                                               else
16889                                                 {
16890                                                   if (((word >> 22) & 0x1) == 0)
16891                                                     {
16892                                                       /* 33222222222211111111110000000000
16893                                                          10987654321098765432109876543210
16894                                                          11010100x01xxxxxxxxxxxxxxxx0xx00
16895                                                          brk.  */
16896                                                       return 752;
16897                                                     }
16898                                                   else
16899                                                     {
16900                                                       /* 33222222222211111111110000000000
16901                                                          10987654321098765432109876543210
16902                                                          11010100x11xxxxxxxxxxxxxxxx0xx00
16903                                                          tcancel.  */
16904                                                       return 1196;
16905                                                     }
16906                                                 }
16907                                             }
16908                                           else
16909                                             {
16910                                               if (((word >> 21) & 0x1) == 0)
16911                                                 {
16912                                                   /* 33222222222211111111110000000000
16913                                                      10987654321098765432109876543210
16914                                                      11010100xx0xxxxxxxxxxxxxxxx0xx10
16915                                                      hvc.  */
16916                                                   return 750;
16917                                                 }
16918                                               else
16919                                                 {
16920                                                   /* 33222222222211111111110000000000
16921                                                      10987654321098765432109876543210
16922                                                      11010100xx1xxxxxxxxxxxxxxxx0xx10
16923                                                      dcps2.  */
16924                                                   return 756;
16925                                                 }
16926                                             }
16927                                         }
16928                                       else
16929                                         {
16930                                           if (((word >> 1) & 0x1) == 0)
16931                                             {
16932                                               if (((word >> 21) & 0x1) == 0)
16933                                                 {
16934                                                   /* 33222222222211111111110000000000
16935                                                      10987654321098765432109876543210
16936                                                      11010100xx0xxxxxxxxxxxxxxxx0xx01
16937                                                      svc.  */
16938                                                   return 749;
16939                                                 }
16940                                               else
16941                                                 {
16942                                                   /* 33222222222211111111110000000000
16943                                                      10987654321098765432109876543210
16944                                                      11010100xx1xxxxxxxxxxxxxxxx0xx01
16945                                                      dcps1.  */
16946                                                   return 755;
16947                                                 }
16948                                             }
16949                                           else
16950                                             {
16951                                               if (((word >> 21) & 0x1) == 0)
16952                                                 {
16953                                                   /* 33222222222211111111110000000000
16954                                                      10987654321098765432109876543210
16955                                                      11010100xx0xxxxxxxxxxxxxxxx0xx11
16956                                                      smc.  */
16957                                                   return 751;
16958                                                 }
16959                                               else
16960                                                 {
16961                                                   /* 33222222222211111111110000000000
16962                                                      10987654321098765432109876543210
16963                                                      11010100xx1xxxxxxxxxxxxxxxx0xx11
16964                                                      dcps3.  */
16965                                                   return 757;
16966                                                 }
16967                                             }
16968                                         }
16969                                     }
16970                                 }
16971                               else
16972                                 {
16973                                   if (((word >> 21) & 0x1) == 0)
16974                                     {
16975                                       if (((word >> 22) & 0x1) == 0)
16976                                         {
16977                                           if (((word >> 23) & 0x1) == 0)
16978                                             {
16979                                               /* 33222222222211111111110000000000
16980                                                  10987654321098765432109876543210
16981                                                  x1010110000xxxxxxxxxxxxxxxx0xxxx
16982                                                  br.  */
16983                                               return 638;
16984                                             }
16985                                           else
16986                                             {
16987                                               /* 33222222222211111111110000000000
16988                                                  10987654321098765432109876543210
16989                                                  x1010110100xxxxxxxxxxxxxxxx0xxxx
16990                                                  eret.  */
16991                                               return 641;
16992                                             }
16993                                         }
16994                                       else
16995                                         {
16996                                           /* 33222222222211111111110000000000
16997                                              10987654321098765432109876543210
16998                                              x1010110x10xxxxxxxxxxxxxxxx0xxxx
16999                                              ret.  */
17000                                           return 640;
17001                                         }
17002                                     }
17003                                   else
17004                                     {
17005                                       if (((word >> 23) & 0x1) == 0)
17006                                         {
17007                                           /* 33222222222211111111110000000000
17008                                              10987654321098765432109876543210
17009                                              x10101100x1xxxxxxxxxxxxxxxx0xxxx
17010                                              blr.  */
17011                                           return 639;
17012                                         }
17013                                       else
17014                                         {
17015                                           /* 33222222222211111111110000000000
17016                                              10987654321098765432109876543210
17017                                              x10101101x1xxxxxxxxxxxxxxxx0xxxx
17018                                              drps.  */
17019                                           return 642;
17020                                         }
17021                                     }
17022                                 }
17023                             }
17024                           else
17025                             {
17026                               if (((word >> 25) & 0x1) == 0)
17027                                 {
17028                                   /* 33222222222211111111110000000000
17029                                      10987654321098765432109876543210
17030                                      x1010100xxxxxxxxxxxxxxxxxxx1xxxx
17031                                      bc.c.  */
17032                                   return 2635;
17033                                 }
17034                               else
17035                                 {
17036                                   if (((word >> 10) & 0x1) == 0)
17037                                     {
17038                                       if (((word >> 21) & 0x1) == 0)
17039                                         {
17040                                           if (((word >> 22) & 0x1) == 0)
17041                                             {
17042                                               if (((word >> 23) & 0x1) == 0)
17043                                                 {
17044                                                   /* 33222222222211111111110000000000
17045                                                      10987654321098765432109876543210
17046                                                      x1010110000xxxxxxxxxx0xxxxx1xxxx
17047                                                      braaz.  */
17048                                                   return 647;
17049                                                 }
17050                                               else
17051                                                 {
17052                                                   /* 33222222222211111111110000000000
17053                                                      10987654321098765432109876543210
17054                                                      x1010110100xxxxxxxxxx0xxxxx1xxxx
17055                                                      eretaa.  */
17056                                                   return 653;
17057                                                 }
17058                                             }
17059                                           else
17060                                             {
17061                                               /* 33222222222211111111110000000000
17062                                                  10987654321098765432109876543210
17063                                                  x1010110x10xxxxxxxxxx0xxxxx1xxxx
17064                                                  retaa.  */
17065                                               return 651;
17066                                             }
17067                                         }
17068                                       else
17069                                         {
17070                                           /* 33222222222211111111110000000000
17071                                              10987654321098765432109876543210
17072                                              x1010110xx1xxxxxxxxxx0xxxxx1xxxx
17073                                              blraaz.  */
17074                                           return 649;
17075                                         }
17076                                     }
17077                                   else
17078                                     {
17079                                       if (((word >> 21) & 0x1) == 0)
17080                                         {
17081                                           if (((word >> 22) & 0x1) == 0)
17082                                             {
17083                                               if (((word >> 23) & 0x1) == 0)
17084                                                 {
17085                                                   /* 33222222222211111111110000000000
17086                                                      10987654321098765432109876543210
17087                                                      x1010110000xxxxxxxxxx1xxxxx1xxxx
17088                                                      brabz.  */
17089                                                   return 648;
17090                                                 }
17091                                               else
17092                                                 {
17093                                                   /* 33222222222211111111110000000000
17094                                                      10987654321098765432109876543210
17095                                                      x1010110100xxxxxxxxxx1xxxxx1xxxx
17096                                                      eretab.  */
17097                                                   return 654;
17098                                                 }
17099                                             }
17100                                           else
17101                                             {
17102                                               /* 33222222222211111111110000000000
17103                                                  10987654321098765432109876543210
17104                                                  x1010110x10xxxxxxxxxx1xxxxx1xxxx
17105                                                  retab.  */
17106                                               return 652;
17107                                             }
17108                                         }
17109                                       else
17110                                         {
17111                                           /* 33222222222211111111110000000000
17112                                              10987654321098765432109876543210
17113                                              x1010110xx1xxxxxxxxxx1xxxxx1xxxx
17114                                              blrabz.  */
17115                                           return 650;
17116                                         }
17117                                     }
17118                                 }
17119                             }
17120                         }
17121                       else
17122                         {
17123                           if (((word >> 21) & 0x1) == 0)
17124                             {
17125                               if (((word >> 25) & 0x1) == 0)
17126                                 {
17127                                   /* 33222222222211111111110000000000
17128                                      10987654321098765432109876543210
17129                                      x1010101xx0xxxxxxxxxxxxxxxxxxxxx
17130                                      xaflag.  */
17131                                   return 811;
17132                                 }
17133                               else
17134                                 {
17135                                   if (((word >> 10) & 0x1) == 0)
17136                                     {
17137                                       /* 33222222222211111111110000000000
17138                                          10987654321098765432109876543210
17139                                          x1010111xx0xxxxxxxxxx0xxxxxxxxxx
17140                                          braa.  */
17141                                       return 643;
17142                                     }
17143                                   else
17144                                     {
17145                                       /* 33222222222211111111110000000000
17146                                          10987654321098765432109876543210
17147                                          x1010111xx0xxxxxxxxxx1xxxxxxxxxx
17148                                          brab.  */
17149                                       return 644;
17150                                     }
17151                                 }
17152                             }
17153                           else
17154                             {
17155                               if (((word >> 25) & 0x1) == 0)
17156                                 {
17157                                   /* 33222222222211111111110000000000
17158                                      10987654321098765432109876543210
17159                                      x1010101xx1xxxxxxxxxxxxxxxxxxxxx
17160                                      tstart.  */
17161                                   return 1193;
17162                                 }
17163                               else
17164                                 {
17165                                   if (((word >> 10) & 0x1) == 0)
17166                                     {
17167                                       /* 33222222222211111111110000000000
17168                                          10987654321098765432109876543210
17169                                          x1010111xx1xxxxxxxxxx0xxxxxxxxxx
17170                                          blraa.  */
17171                                       return 645;
17172                                     }
17173                                   else
17174                                     {
17175                                       /* 33222222222211111111110000000000
17176                                          10987654321098765432109876543210
17177                                          x1010111xx1xxxxxxxxxx1xxxxxxxxxx
17178                                          blrab.  */
17179                                       return 646;
17180                                     }
17181                                 }
17182                             }
17183                         }
17184                     }
17185                 }
17186               else
17187                 {
17188                   if (((word >> 24) & 0x1) == 0)
17189                     {
17190                       if (((word >> 25) & 0x1) == 0)
17191                         {
17192                           /* 33222222222211111111110000000000
17193                              10987654321098765432109876543210
17194                              xx110100xxxxxxxxxxxxxxxxxxxxxxxx
17195                              cbz.  */
17196                           return 655;
17197                         }
17198                       else
17199                         {
17200                           /* 33222222222211111111110000000000
17201                              10987654321098765432109876543210
17202                              xx110110xxxxxxxxxxxxxxxxxxxxxxxx
17203                              tbz.  */
17204                           return 1252;
17205                         }
17206                     }
17207                   else
17208                     {
17209                       if (((word >> 25) & 0x1) == 0)
17210                         {
17211                           /* 33222222222211111111110000000000
17212                              10987654321098765432109876543210
17213                              xx110101xxxxxxxxxxxxxxxxxxxxxxxx
17214                              cbnz.  */
17215                           return 656;
17216                         }
17217                       else
17218                         {
17219                           /* 33222222222211111111110000000000
17220                              10987654321098765432109876543210
17221                              xx110111xxxxxxxxxxxxxxxxxxxxxxxx
17222                              tbnz.  */
17223                           return 1253;
17224                         }
17225                     }
17226                 }
17227             }
17228         }
17229       else
17230         {
17231           if (((word >> 25) & 0x1) == 0)
17232             {
17233               if (((word >> 28) & 0x1) == 0)
17234                 {
17235                   if (((word >> 22) & 0x1) == 0)
17236                     {
17237                       if (((word >> 23) & 0x1) == 0)
17238                         {
17239                           if (((word >> 24) & 0x1) == 0)
17240                             {
17241                               if (((word >> 29) & 0x1) == 0)
17242                                 {
17243                                   /* 33222222222211111111110000000000
17244                                      10987654321098765432109876543210
17245                                      xx00110000xxxxxxxxxxxxxxxxxxxxxx
17246                                      st4.  */
17247                                   return 440;
17248                                 }
17249                               else
17250                                 {
17251                                   /* 33222222222211111111110000000000
17252                                      10987654321098765432109876543210
17253                                      xx10110000xxxxxxxxxxxxxxxxxxxxxx
17254                                      stnp.  */
17255                                   return 973;
17256                                 }
17257                             }
17258                           else
17259                             {
17260                               if (((word >> 29) & 0x1) == 0)
17261                                 {
17262                                   if (((word >> 13) & 0x1) == 0)
17263                                     {
17264                                       if (((word >> 21) & 0x1) == 0)
17265                                         {
17266                                           /* 33222222222211111111110000000000
17267                                              10987654321098765432109876543210
17268                                              xx001101000xxxxxxx0xxxxxxxxxxxxx
17269                                              st1.  */
17270                                           return 456;
17271                                         }
17272                                       else
17273                                         {
17274                                           /* 33222222222211111111110000000000
17275                                              10987654321098765432109876543210
17276                                              xx001101001xxxxxxx0xxxxxxxxxxxxx
17277                                              st2.  */
17278                                           return 458;
17279                                         }
17280                                     }
17281                                   else
17282                                     {
17283                                       if (((word >> 21) & 0x1) == 0)
17284                                         {
17285                                           /* 33222222222211111111110000000000
17286                                              10987654321098765432109876543210
17287                                              xx001101000xxxxxxx1xxxxxxxxxxxxx
17288                                              st3.  */
17289                                           return 457;
17290                                         }
17291                                       else
17292                                         {
17293                                           /* 33222222222211111111110000000000
17294                                              10987654321098765432109876543210
17295                                              xx001101001xxxxxxx1xxxxxxxxxxxxx
17296                                              st4.  */
17297                                           return 459;
17298                                         }
17299                                     }
17300                                 }
17301                               else
17302                                 {
17303                                   /* 33222222222211111111110000000000
17304                                      10987654321098765432109876543210
17305                                      xx10110100xxxxxxxxxxxxxxxxxxxxxx
17306                                      stp.  */
17307                                   return 977;
17308                                 }
17309                             }
17310                         }
17311                       else
17312                         {
17313                           if (((word >> 29) & 0x1) == 0)
17314                             {
17315                               if (((word >> 21) & 0x1) == 0)
17316                                 {
17317                                   if (((word >> 24) & 0x1) == 0)
17318                                     {
17319                                       /* 33222222222211111111110000000000
17320                                          10987654321098765432109876543210
17321                                          xx001100100xxxxxxxxxxxxxxxxxxxxx
17322                                          st4.  */
17323                                       return 448;
17324                                     }
17325                                   else
17326                                     {
17327                                       if (((word >> 13) & 0x1) == 0)
17328                                         {
17329                                           /* 33222222222211111111110000000000
17330                                              10987654321098765432109876543210
17331                                              xx001101100xxxxxxx0xxxxxxxxxxxxx
17332                                              st1.  */
17333                                           return 468;
17334                                         }
17335                                       else
17336                                         {
17337                                           /* 33222222222211111111110000000000
17338                                              10987654321098765432109876543210
17339                                              xx001101100xxxxxxx1xxxxxxxxxxxxx
17340                                              st3.  */
17341                                           return 469;
17342                                         }
17343                                     }
17344                                 }
17345                               else
17346                                 {
17347                                   if (((word >> 13) & 0x1) == 0)
17348                                     {
17349                                       /* 33222222222211111111110000000000
17350                                          10987654321098765432109876543210
17351                                          xx00110x101xxxxxxx0xxxxxxxxxxxxx
17352                                          st2.  */
17353                                       return 470;
17354                                     }
17355                                   else
17356                                     {
17357                                       /* 33222222222211111111110000000000
17358                                          10987654321098765432109876543210
17359                                          xx00110x101xxxxxxx1xxxxxxxxxxxxx
17360                                          st4.  */
17361                                       return 471;
17362                                     }
17363                                 }
17364                             }
17365                           else
17366                             {
17367                               /* 33222222222211111111110000000000
17368                                  10987654321098765432109876543210
17369                                  xx10110x10xxxxxxxxxxxxxxxxxxxxxx
17370                                  stp.  */
17371                               return 983;
17372                             }
17373                         }
17374                     }
17375                   else
17376                     {
17377                       if (((word >> 23) & 0x1) == 0)
17378                         {
17379                           if (((word >> 24) & 0x1) == 0)
17380                             {
17381                               if (((word >> 29) & 0x1) == 0)
17382                                 {
17383                                   /* 33222222222211111111110000000000
17384                                      10987654321098765432109876543210
17385                                      xx00110001xxxxxxxxxxxxxxxxxxxxxx
17386                                      ld4.  */
17387                                   return 444;
17388                                 }
17389                               else
17390                                 {
17391                                   /* 33222222222211111111110000000000
17392                                      10987654321098765432109876543210
17393                                      xx10110001xxxxxxxxxxxxxxxxxxxxxx
17394                                      ldnp.  */
17395                                   return 974;
17396                                 }
17397                             }
17398                           else
17399                             {
17400                               if (((word >> 29) & 0x1) == 0)
17401                                 {
17402                                   if (((word >> 13) & 0x1) == 0)
17403                                     {
17404                                       if (((word >> 21) & 0x1) == 0)
17405                                         {
17406                                           /* 33222222222211111111110000000000
17407                                              10987654321098765432109876543210
17408                                              xx001101010xxxxxxx0xxxxxxxxxxxxx
17409                                              ld1.  */
17410                                           return 460;
17411                                         }
17412                                       else
17413                                         {
17414                                           /* 33222222222211111111110000000000
17415                                              10987654321098765432109876543210
17416                                              xx001101011xxxxxxx0xxxxxxxxxxxxx
17417                                              ld2.  */
17418                                           return 464;
17419                                         }
17420                                     }
17421                                   else
17422                                     {
17423                                       if (((word >> 21) & 0x1) == 0)
17424                                         {
17425                                           /* 33222222222211111111110000000000
17426                                              10987654321098765432109876543210
17427                                              xx001101010xxxxxxx1xxxxxxxxxxxxx
17428                                              ld3.  */
17429                                           return 461;
17430                                         }
17431                                       else
17432                                         {
17433                                           /* 33222222222211111111110000000000
17434                                              10987654321098765432109876543210
17435                                              xx001101011xxxxxxx1xxxxxxxxxxxxx
17436                                              ld4.  */
17437                                           return 465;
17438                                         }
17439                                     }
17440                                 }
17441                               else
17442                                 {
17443                                   /* 33222222222211111111110000000000
17444                                      10987654321098765432109876543210
17445                                      xx10110101xxxxxxxxxxxxxxxxxxxxxx
17446                                      ldp.  */
17447                                   return 978;
17448                                 }
17449                             }
17450                         }
17451                       else
17452                         {
17453                           if (((word >> 29) & 0x1) == 0)
17454                             {
17455                               if (((word >> 21) & 0x1) == 0)
17456                                 {
17457                                   if (((word >> 24) & 0x1) == 0)
17458                                     {
17459                                       /* 33222222222211111111110000000000
17460                                          10987654321098765432109876543210
17461                                          xx001100110xxxxxxxxxxxxxxxxxxxxx
17462                                          ld4.  */
17463                                       return 452;
17464                                     }
17465                                   else
17466                                     {
17467                                       if (((word >> 13) & 0x1) == 0)
17468                                         {
17469                                           /* 33222222222211111111110000000000
17470                                              10987654321098765432109876543210
17471                                              xx001101110xxxxxxx0xxxxxxxxxxxxx
17472                                              ld1.  */
17473                                           return 472;
17474                                         }
17475                                       else
17476                                         {
17477                                           /* 33222222222211111111110000000000
17478                                              10987654321098765432109876543210
17479                                              xx001101110xxxxxxx1xxxxxxxxxxxxx
17480                                              ld3.  */
17481                                           return 473;
17482                                         }
17483                                     }
17484                                 }
17485                               else
17486                                 {
17487                                   if (((word >> 13) & 0x1) == 0)
17488                                     {
17489                                       /* 33222222222211111111110000000000
17490                                          10987654321098765432109876543210
17491                                          xx00110x111xxxxxxx0xxxxxxxxxxxxx
17492                                          ld2.  */
17493                                       return 476;
17494                                     }
17495                                   else
17496                                     {
17497                                       /* 33222222222211111111110000000000
17498                                          10987654321098765432109876543210
17499                                          xx00110x111xxxxxxx1xxxxxxxxxxxxx
17500                                          ld4.  */
17501                                       return 477;
17502                                     }
17503                                 }
17504                             }
17505                           else
17506                             {
17507                               /* 33222222222211111111110000000000
17508                                  10987654321098765432109876543210
17509                                  xx10110x11xxxxxxxxxxxxxxxxxxxxxx
17510                                  ldp.  */
17511                               return 984;
17512                             }
17513                         }
17514                     }
17515                 }
17516               else
17517                 {
17518                   if (((word >> 24) & 0x1) == 0)
17519                     {
17520                       if (((word >> 29) & 0x1) == 0)
17521                         {
17522                           /* 33222222222211111111110000000000
17523                              10987654321098765432109876543210
17524                              xx011100xxxxxxxxxxxxxxxxxxxxxxxx
17525                              ldr.  */
17526                           return 988;
17527                         }
17528                       else
17529                         {
17530                           if (((word >> 10) & 0x1) == 0)
17531                             {
17532                               if (((word >> 11) & 0x1) == 0)
17533                                 {
17534                                   if (((word >> 22) & 0x1) == 0)
17535                                     {
17536                                       /* 33222222222211111111110000000000
17537                                          10987654321098765432109876543210
17538                                          xx111100x0xxxxxxxxxx00xxxxxxxxxx
17539                                          stur.  */
17540                                       return 925;
17541                                     }
17542                                   else
17543                                     {
17544                                       /* 33222222222211111111110000000000
17545                                          10987654321098765432109876543210
17546                                          xx111100x1xxxxxxxxxx00xxxxxxxxxx
17547                                          ldur.  */
17548                                       return 926;
17549                                     }
17550                                 }
17551                               else
17552                                 {
17553                                   if (((word >> 22) & 0x1) == 0)
17554                                     {
17555                                       /* 33222222222211111111110000000000
17556                                          10987654321098765432109876543210
17557                                          xx111100x0xxxxxxxxxx10xxxxxxxxxx
17558                                          str.  */
17559                                       return 904;
17560                                     }
17561                                   else
17562                                     {
17563                                       /* 33222222222211111111110000000000
17564                                          10987654321098765432109876543210
17565                                          xx111100x1xxxxxxxxxx10xxxxxxxxxx
17566                                          ldr.  */
17567                                       return 905;
17568                                     }
17569                                 }
17570                             }
17571                           else
17572                             {
17573                               if (((word >> 22) & 0x1) == 0)
17574                                 {
17575                                   /* 33222222222211111111110000000000
17576                                      10987654321098765432109876543210
17577                                      xx111100x0xxxxxxxxxxx1xxxxxxxxxx
17578                                      str.  */
17579                                   return 873;
17580                                 }
17581                               else
17582                                 {
17583                                   /* 33222222222211111111110000000000
17584                                      10987654321098765432109876543210
17585                                      xx111100x1xxxxxxxxxxx1xxxxxxxxxx
17586                                      ldr.  */
17587                                   return 874;
17588                                 }
17589                             }
17590                         }
17591                     }
17592                   else
17593                     {
17594                       if (((word >> 22) & 0x1) == 0)
17595                         {
17596                           if (((word >> 29) & 0x1) == 0)
17597                             {
17598                               if (((word >> 12) & 0x1) == 0)
17599                                 {
17600                                   if (((word >> 13) & 0x1) == 0)
17601                                     {
17602                                       if (((word >> 14) & 0x1) == 0)
17603                                         {
17604                                           if (((word >> 15) & 0x1) == 0)
17605                                             {
17606                                               if (((word >> 23) & 0x1) == 0)
17607                                                 {
17608                                                   /* 33222222222211111111110000000000
17609                                                      10987654321098765432109876543210
17610                                                      xx01110100xxxxxx0000xxxxxxxxxxxx
17611                                                      cpyp.  */
17612                                                   return 2563;
17613                                                 }
17614                                               else
17615                                                 {
17616                                                   /* 33222222222211111111110000000000
17617                                                      10987654321098765432109876543210
17618                                                      xx01110110xxxxxx0000xxxxxxxxxxxx
17619                                                      cpye.  */
17620                                                   return 2565;
17621                                                 }
17622                                             }
17623                                           else
17624                                             {
17625                                               if (((word >> 23) & 0x1) == 0)
17626                                                 {
17627                                                   /* 33222222222211111111110000000000
17628                                                      10987654321098765432109876543210
17629                                                      xx01110100xxxxxx1000xxxxxxxxxxxx
17630                                                      cpyprn.  */
17631                                                   return 2569;
17632                                                 }
17633                                               else
17634                                                 {
17635                                                   /* 33222222222211111111110000000000
17636                                                      10987654321098765432109876543210
17637                                                      xx01110110xxxxxx1000xxxxxxxxxxxx
17638                                                      cpyern.  */
17639                                                   return 2571;
17640                                                 }
17641                                             }
17642                                         }
17643                                       else
17644                                         {
17645                                           if (((word >> 15) & 0x1) == 0)
17646                                             {
17647                                               if (((word >> 23) & 0x1) == 0)
17648                                                 {
17649                                                   /* 33222222222211111111110000000000
17650                                                      10987654321098765432109876543210
17651                                                      xx01110100xxxxxx0100xxxxxxxxxxxx
17652                                                      cpypwn.  */
17653                                                   return 2566;
17654                                                 }
17655                                               else
17656                                                 {
17657                                                   /* 33222222222211111111110000000000
17658                                                      10987654321098765432109876543210
17659                                                      xx01110110xxxxxx0100xxxxxxxxxxxx
17660                                                      cpyewn.  */
17661                                                   return 2568;
17662                                                 }
17663                                             }
17664                                           else
17665                                             {
17666                                               if (((word >> 23) & 0x1) == 0)
17667                                                 {
17668                                                   /* 33222222222211111111110000000000
17669                                                      10987654321098765432109876543210
17670                                                      xx01110100xxxxxx1100xxxxxxxxxxxx
17671                                                      cpypn.  */
17672                                                   return 2572;
17673                                                 }
17674                                               else
17675                                                 {
17676                                                   /* 33222222222211111111110000000000
17677                                                      10987654321098765432109876543210
17678                                                      xx01110110xxxxxx1100xxxxxxxxxxxx
17679                                                      cpyen.  */
17680                                                   return 2574;
17681                                                 }
17682                                             }
17683                                         }
17684                                     }
17685                                   else
17686                                     {
17687                                       if (((word >> 14) & 0x1) == 0)
17688                                         {
17689                                           if (((word >> 15) & 0x1) == 0)
17690                                             {
17691                                               if (((word >> 23) & 0x1) == 0)
17692                                                 {
17693                                                   /* 33222222222211111111110000000000
17694                                                      10987654321098765432109876543210
17695                                                      xx01110100xxxxxx0010xxxxxxxxxxxx
17696                                                      cpyprt.  */
17697                                                   return 2587;
17698                                                 }
17699                                               else
17700                                                 {
17701                                                   /* 33222222222211111111110000000000
17702                                                      10987654321098765432109876543210
17703                                                      xx01110110xxxxxx0010xxxxxxxxxxxx
17704                                                      cpyert.  */
17705                                                   return 2589;
17706                                                 }
17707                                             }
17708                                           else
17709                                             {
17710                                               if (((word >> 23) & 0x1) == 0)
17711                                                 {
17712                                                   /* 33222222222211111111110000000000
17713                                                      10987654321098765432109876543210
17714                                                      xx01110100xxxxxx1010xxxxxxxxxxxx
17715                                                      cpyprtrn.  */
17716                                                   return 2593;
17717                                                 }
17718                                               else
17719                                                 {
17720                                                   /* 33222222222211111111110000000000
17721                                                      10987654321098765432109876543210
17722                                                      xx01110110xxxxxx1010xxxxxxxxxxxx
17723                                                      cpyertrn.  */
17724                                                   return 2595;
17725                                                 }
17726                                             }
17727                                         }
17728                                       else
17729                                         {
17730                                           if (((word >> 15) & 0x1) == 0)
17731                                             {
17732                                               if (((word >> 23) & 0x1) == 0)
17733                                                 {
17734                                                   /* 33222222222211111111110000000000
17735                                                      10987654321098765432109876543210
17736                                                      xx01110100xxxxxx0110xxxxxxxxxxxx
17737                                                      cpyprtwn.  */
17738                                                   return 2590;
17739                                                 }
17740                                               else
17741                                                 {
17742                                                   /* 33222222222211111111110000000000
17743                                                      10987654321098765432109876543210
17744                                                      xx01110110xxxxxx0110xxxxxxxxxxxx
17745                                                      cpyertwn.  */
17746                                                   return 2592;
17747                                                 }
17748                                             }
17749                                           else
17750                                             {
17751                                               if (((word >> 23) & 0x1) == 0)
17752                                                 {
17753                                                   /* 33222222222211111111110000000000
17754                                                      10987654321098765432109876543210
17755                                                      xx01110100xxxxxx1110xxxxxxxxxxxx
17756                                                      cpyprtn.  */
17757                                                   return 2596;
17758                                                 }
17759                                               else
17760                                                 {
17761                                                   /* 33222222222211111111110000000000
17762                                                      10987654321098765432109876543210
17763                                                      xx01110110xxxxxx1110xxxxxxxxxxxx
17764                                                      cpyertn.  */
17765                                                   return 2598;
17766                                                 }
17767                                             }
17768                                         }
17769                                     }
17770                                 }
17771                               else
17772                                 {
17773                                   if (((word >> 13) & 0x1) == 0)
17774                                     {
17775                                       if (((word >> 14) & 0x1) == 0)
17776                                         {
17777                                           if (((word >> 15) & 0x1) == 0)
17778                                             {
17779                                               if (((word >> 23) & 0x1) == 0)
17780                                                 {
17781                                                   /* 33222222222211111111110000000000
17782                                                      10987654321098765432109876543210
17783                                                      xx01110100xxxxxx0001xxxxxxxxxxxx
17784                                                      cpypwt.  */
17785                                                   return 2575;
17786                                                 }
17787                                               else
17788                                                 {
17789                                                   /* 33222222222211111111110000000000
17790                                                      10987654321098765432109876543210
17791                                                      xx01110110xxxxxx0001xxxxxxxxxxxx
17792                                                      cpyewt.  */
17793                                                   return 2577;
17794                                                 }
17795                                             }
17796                                           else
17797                                             {
17798                                               if (((word >> 23) & 0x1) == 0)
17799                                                 {
17800                                                   /* 33222222222211111111110000000000
17801                                                      10987654321098765432109876543210
17802                                                      xx01110100xxxxxx1001xxxxxxxxxxxx
17803                                                      cpypwtrn.  */
17804                                                   return 2581;
17805                                                 }
17806                                               else
17807                                                 {
17808                                                   /* 33222222222211111111110000000000
17809                                                      10987654321098765432109876543210
17810                                                      xx01110110xxxxxx1001xxxxxxxxxxxx
17811                                                      cpyewtrn.  */
17812                                                   return 2583;
17813                                                 }
17814                                             }
17815                                         }
17816                                       else
17817                                         {
17818                                           if (((word >> 15) & 0x1) == 0)
17819                                             {
17820                                               if (((word >> 23) & 0x1) == 0)
17821                                                 {
17822                                                   /* 33222222222211111111110000000000
17823                                                      10987654321098765432109876543210
17824                                                      xx01110100xxxxxx0101xxxxxxxxxxxx
17825                                                      cpypwtwn.  */
17826                                                   return 2578;
17827                                                 }
17828                                               else
17829                                                 {
17830                                                   /* 33222222222211111111110000000000
17831                                                      10987654321098765432109876543210
17832                                                      xx01110110xxxxxx0101xxxxxxxxxxxx
17833                                                      cpyewtwn.  */
17834                                                   return 2580;
17835                                                 }
17836                                             }
17837                                           else
17838                                             {
17839                                               if (((word >> 23) & 0x1) == 0)
17840                                                 {
17841                                                   /* 33222222222211111111110000000000
17842                                                      10987654321098765432109876543210
17843                                                      xx01110100xxxxxx1101xxxxxxxxxxxx
17844                                                      cpypwtn.  */
17845                                                   return 2584;
17846                                                 }
17847                                               else
17848                                                 {
17849                                                   /* 33222222222211111111110000000000
17850                                                      10987654321098765432109876543210
17851                                                      xx01110110xxxxxx1101xxxxxxxxxxxx
17852                                                      cpyewtn.  */
17853                                                   return 2586;
17854                                                 }
17855                                             }
17856                                         }
17857                                     }
17858                                   else
17859                                     {
17860                                       if (((word >> 14) & 0x1) == 0)
17861                                         {
17862                                           if (((word >> 15) & 0x1) == 0)
17863                                             {
17864                                               if (((word >> 23) & 0x1) == 0)
17865                                                 {
17866                                                   /* 33222222222211111111110000000000
17867                                                      10987654321098765432109876543210
17868                                                      xx01110100xxxxxx0011xxxxxxxxxxxx
17869                                                      cpypt.  */
17870                                                   return 2599;
17871                                                 }
17872                                               else
17873                                                 {
17874                                                   /* 33222222222211111111110000000000
17875                                                      10987654321098765432109876543210
17876                                                      xx01110110xxxxxx0011xxxxxxxxxxxx
17877                                                      cpyet.  */
17878                                                   return 2601;
17879                                                 }
17880                                             }
17881                                           else
17882                                             {
17883                                               if (((word >> 23) & 0x1) == 0)
17884                                                 {
17885                                                   /* 33222222222211111111110000000000
17886                                                      10987654321098765432109876543210
17887                                                      xx01110100xxxxxx1011xxxxxxxxxxxx
17888                                                      cpyptrn.  */
17889                                                   return 2605;
17890                                                 }
17891                                               else
17892                                                 {
17893                                                   /* 33222222222211111111110000000000
17894                                                      10987654321098765432109876543210
17895                                                      xx01110110xxxxxx1011xxxxxxxxxxxx
17896                                                      cpyetrn.  */
17897                                                   return 2607;
17898                                                 }
17899                                             }
17900                                         }
17901                                       else
17902                                         {
17903                                           if (((word >> 15) & 0x1) == 0)
17904                                             {
17905                                               if (((word >> 23) & 0x1) == 0)
17906                                                 {
17907                                                   /* 33222222222211111111110000000000
17908                                                      10987654321098765432109876543210
17909                                                      xx01110100xxxxxx0111xxxxxxxxxxxx
17910                                                      cpyptwn.  */
17911                                                   return 2602;
17912                                                 }
17913                                               else
17914                                                 {
17915                                                   /* 33222222222211111111110000000000
17916                                                      10987654321098765432109876543210
17917                                                      xx01110110xxxxxx0111xxxxxxxxxxxx
17918                                                      cpyetwn.  */
17919                                                   return 2604;
17920                                                 }
17921                                             }
17922                                           else
17923                                             {
17924                                               if (((word >> 23) & 0x1) == 0)
17925                                                 {
17926                                                   /* 33222222222211111111110000000000
17927                                                      10987654321098765432109876543210
17928                                                      xx01110100xxxxxx1111xxxxxxxxxxxx
17929                                                      cpyptn.  */
17930                                                   return 2608;
17931                                                 }
17932                                               else
17933                                                 {
17934                                                   /* 33222222222211111111110000000000
17935                                                      10987654321098765432109876543210
17936                                                      xx01110110xxxxxx1111xxxxxxxxxxxx
17937                                                      cpyetn.  */
17938                                                   return 2610;
17939                                                 }
17940                                             }
17941                                         }
17942                                     }
17943                                 }
17944                             }
17945                           else
17946                             {
17947                               /* 33222222222211111111110000000000
17948                                  10987654321098765432109876543210
17949                                  xx111101x0xxxxxxxxxxxxxxxxxxxxxx
17950                                  str.  */
17951                               return 892;
17952                             }
17953                         }
17954                       else
17955                         {
17956                           if (((word >> 29) & 0x1) == 0)
17957                             {
17958                               if (((word >> 12) & 0x1) == 0)
17959                                 {
17960                                   if (((word >> 13) & 0x1) == 0)
17961                                     {
17962                                       if (((word >> 14) & 0x1) == 0)
17963                                         {
17964                                           if (((word >> 15) & 0x1) == 0)
17965                                             {
17966                                               if (((word >> 23) & 0x1) == 0)
17967                                                 {
17968                                                   /* 33222222222211111111110000000000
17969                                                      10987654321098765432109876543210
17970                                                      xx01110101xxxxxx0000xxxxxxxxxxxx
17971                                                      cpym.  */
17972                                                   return 2564;
17973                                                 }
17974                                               else
17975                                                 {
17976                                                   /* 33222222222211111111110000000000
17977                                                      10987654321098765432109876543210
17978                                                      xx01110111xxxxxx0000xxxxxxxxxxxx
17979                                                      setgp.  */
17980                                                   return 2623;
17981                                                 }
17982                                             }
17983                                           else
17984                                             {
17985                                               if (((word >> 23) & 0x1) == 0)
17986                                                 {
17987                                                   /* 33222222222211111111110000000000
17988                                                      10987654321098765432109876543210
17989                                                      xx01110101xxxxxx1000xxxxxxxxxxxx
17990                                                      cpymrn.  */
17991                                                   return 2570;
17992                                                 }
17993                                               else
17994                                                 {
17995                                                   /* 33222222222211111111110000000000
17996                                                      10987654321098765432109876543210
17997                                                      xx01110111xxxxxx1000xxxxxxxxxxxx
17998                                                      setge.  */
17999                                                   return 2625;
18000                                                 }
18001                                             }
18002                                         }
18003                                       else
18004                                         {
18005                                           if (((word >> 15) & 0x1) == 0)
18006                                             {
18007                                               if (((word >> 23) & 0x1) == 0)
18008                                                 {
18009                                                   /* 33222222222211111111110000000000
18010                                                      10987654321098765432109876543210
18011                                                      xx01110101xxxxxx0100xxxxxxxxxxxx
18012                                                      cpymwn.  */
18013                                                   return 2567;
18014                                                 }
18015                                               else
18016                                                 {
18017                                                   /* 33222222222211111111110000000000
18018                                                      10987654321098765432109876543210
18019                                                      xx01110111xxxxxx0100xxxxxxxxxxxx
18020                                                      setgm.  */
18021                                                   return 2624;
18022                                                 }
18023                                             }
18024                                           else
18025                                             {
18026                                               /* 33222222222211111111110000000000
18027                                                  10987654321098765432109876543210
18028                                                  xx011101x1xxxxxx1100xxxxxxxxxxxx
18029                                                  cpymn.  */
18030                                               return 2573;
18031                                             }
18032                                         }
18033                                     }
18034                                   else
18035                                     {
18036                                       if (((word >> 14) & 0x1) == 0)
18037                                         {
18038                                           if (((word >> 15) & 0x1) == 0)
18039                                             {
18040                                               if (((word >> 23) & 0x1) == 0)
18041                                                 {
18042                                                   /* 33222222222211111111110000000000
18043                                                      10987654321098765432109876543210
18044                                                      xx01110101xxxxxx0010xxxxxxxxxxxx
18045                                                      cpymrt.  */
18046                                                   return 2588;
18047                                                 }
18048                                               else
18049                                                 {
18050                                                   /* 33222222222211111111110000000000
18051                                                      10987654321098765432109876543210
18052                                                      xx01110111xxxxxx0010xxxxxxxxxxxx
18053                                                      setgpn.  */
18054                                                   return 2629;
18055                                                 }
18056                                             }
18057                                           else
18058                                             {
18059                                               if (((word >> 23) & 0x1) == 0)
18060                                                 {
18061                                                   /* 33222222222211111111110000000000
18062                                                      10987654321098765432109876543210
18063                                                      xx01110101xxxxxx1010xxxxxxxxxxxx
18064                                                      cpymrtrn.  */
18065                                                   return 2594;
18066                                                 }
18067                                               else
18068                                                 {
18069                                                   /* 33222222222211111111110000000000
18070                                                      10987654321098765432109876543210
18071                                                      xx01110111xxxxxx1010xxxxxxxxxxxx
18072                                                      setgen.  */
18073                                                   return 2631;
18074                                                 }
18075                                             }
18076                                         }
18077                                       else
18078                                         {
18079                                           if (((word >> 15) & 0x1) == 0)
18080                                             {
18081                                               if (((word >> 23) & 0x1) == 0)
18082                                                 {
18083                                                   /* 33222222222211111111110000000000
18084                                                      10987654321098765432109876543210
18085                                                      xx01110101xxxxxx0110xxxxxxxxxxxx
18086                                                      cpymrtwn.  */
18087                                                   return 2591;
18088                                                 }
18089                                               else
18090                                                 {
18091                                                   /* 33222222222211111111110000000000
18092                                                      10987654321098765432109876543210
18093                                                      xx01110111xxxxxx0110xxxxxxxxxxxx
18094                                                      setgmn.  */
18095                                                   return 2630;
18096                                                 }
18097                                             }
18098                                           else
18099                                             {
18100                                               /* 33222222222211111111110000000000
18101                                                  10987654321098765432109876543210
18102                                                  xx011101x1xxxxxx1110xxxxxxxxxxxx
18103                                                  cpymrtn.  */
18104                                               return 2597;
18105                                             }
18106                                         }
18107                                     }
18108                                 }
18109                               else
18110                                 {
18111                                   if (((word >> 13) & 0x1) == 0)
18112                                     {
18113                                       if (((word >> 14) & 0x1) == 0)
18114                                         {
18115                                           if (((word >> 15) & 0x1) == 0)
18116                                             {
18117                                               if (((word >> 23) & 0x1) == 0)
18118                                                 {
18119                                                   /* 33222222222211111111110000000000
18120                                                      10987654321098765432109876543210
18121                                                      xx01110101xxxxxx0001xxxxxxxxxxxx
18122                                                      cpymwt.  */
18123                                                   return 2576;
18124                                                 }
18125                                               else
18126                                                 {
18127                                                   /* 33222222222211111111110000000000
18128                                                      10987654321098765432109876543210
18129                                                      xx01110111xxxxxx0001xxxxxxxxxxxx
18130                                                      setgpt.  */
18131                                                   return 2626;
18132                                                 }
18133                                             }
18134                                           else
18135                                             {
18136                                               if (((word >> 23) & 0x1) == 0)
18137                                                 {
18138                                                   /* 33222222222211111111110000000000
18139                                                      10987654321098765432109876543210
18140                                                      xx01110101xxxxxx1001xxxxxxxxxxxx
18141                                                      cpymwtrn.  */
18142                                                   return 2582;
18143                                                 }
18144                                               else
18145                                                 {
18146                                                   /* 33222222222211111111110000000000
18147                                                      10987654321098765432109876543210
18148                                                      xx01110111xxxxxx1001xxxxxxxxxxxx
18149                                                      setget.  */
18150                                                   return 2628;
18151                                                 }
18152                                             }
18153                                         }
18154                                       else
18155                                         {
18156                                           if (((word >> 15) & 0x1) == 0)
18157                                             {
18158                                               if (((word >> 23) & 0x1) == 0)
18159                                                 {
18160                                                   /* 33222222222211111111110000000000
18161                                                      10987654321098765432109876543210
18162                                                      xx01110101xxxxxx0101xxxxxxxxxxxx
18163                                                      cpymwtwn.  */
18164                                                   return 2579;
18165                                                 }
18166                                               else
18167                                                 {
18168                                                   /* 33222222222211111111110000000000
18169                                                      10987654321098765432109876543210
18170                                                      xx01110111xxxxxx0101xxxxxxxxxxxx
18171                                                      setgmt.  */
18172                                                   return 2627;
18173                                                 }
18174                                             }
18175                                           else
18176                                             {
18177                                               /* 33222222222211111111110000000000
18178                                                  10987654321098765432109876543210
18179                                                  xx011101x1xxxxxx1101xxxxxxxxxxxx
18180                                                  cpymwtn.  */
18181                                               return 2585;
18182                                             }
18183                                         }
18184                                     }
18185                                   else
18186                                     {
18187                                       if (((word >> 14) & 0x1) == 0)
18188                                         {
18189                                           if (((word >> 15) & 0x1) == 0)
18190                                             {
18191                                               if (((word >> 23) & 0x1) == 0)
18192                                                 {
18193                                                   /* 33222222222211111111110000000000
18194                                                      10987654321098765432109876543210
18195                                                      xx01110101xxxxxx0011xxxxxxxxxxxx
18196                                                      cpymt.  */
18197                                                   return 2600;
18198                                                 }
18199                                               else
18200                                                 {
18201                                                   /* 33222222222211111111110000000000
18202                                                      10987654321098765432109876543210
18203                                                      xx01110111xxxxxx0011xxxxxxxxxxxx
18204                                                      setgptn.  */
18205                                                   return 2632;
18206                                                 }
18207                                             }
18208                                           else
18209                                             {
18210                                               if (((word >> 23) & 0x1) == 0)
18211                                                 {
18212                                                   /* 33222222222211111111110000000000
18213                                                      10987654321098765432109876543210
18214                                                      xx01110101xxxxxx1011xxxxxxxxxxxx
18215                                                      cpymtrn.  */
18216                                                   return 2606;
18217                                                 }
18218                                               else
18219                                                 {
18220                                                   /* 33222222222211111111110000000000
18221                                                      10987654321098765432109876543210
18222                                                      xx01110111xxxxxx1011xxxxxxxxxxxx
18223                                                      setgetn.  */
18224                                                   return 2634;
18225                                                 }
18226                                             }
18227                                         }
18228                                       else
18229                                         {
18230                                           if (((word >> 15) & 0x1) == 0)
18231                                             {
18232                                               if (((word >> 23) & 0x1) == 0)
18233                                                 {
18234                                                   /* 33222222222211111111110000000000
18235                                                      10987654321098765432109876543210
18236                                                      xx01110101xxxxxx0111xxxxxxxxxxxx
18237                                                      cpymtwn.  */
18238                                                   return 2603;
18239                                                 }
18240                                               else
18241                                                 {
18242                                                   /* 33222222222211111111110000000000
18243                                                      10987654321098765432109876543210
18244                                                      xx01110111xxxxxx0111xxxxxxxxxxxx
18245                                                      setgmtn.  */
18246                                                   return 2633;
18247                                                 }
18248                                             }
18249                                           else
18250                                             {
18251                                               /* 33222222222211111111110000000000
18252                                                  10987654321098765432109876543210
18253                                                  xx011101x1xxxxxx1111xxxxxxxxxxxx
18254                                                  cpymtn.  */
18255                                               return 2609;
18256                                             }
18257                                         }
18258                                     }
18259                                 }
18260                             }
18261                           else
18262                             {
18263                               /* 33222222222211111111110000000000
18264                                  10987654321098765432109876543210
18265                                  xx111101x1xxxxxxxxxxxxxxxxxxxxxx
18266                                  ldr.  */
18267                               return 893;
18268                             }
18269                         }
18270                     }
18271                 }
18272             }
18273           else
18274             {
18275               if (((word >> 24) & 0x1) == 0)
18276                 {
18277                   if (((word >> 21) & 0x1) == 0)
18278                     {
18279                       if (((word >> 28) & 0x1) == 0)
18280                         {
18281                           if (((word >> 29) & 0x1) == 0)
18282                             {
18283                               if (((word >> 31) & 0x1) == 0)
18284                                 {
18285                                   if (((word >> 10) & 0x1) == 0)
18286                                     {
18287                                       if (((word >> 11) & 0x1) == 0)
18288                                         {
18289                                           if (((word >> 12) & 0x1) == 0)
18290                                             {
18291                                               /* 33222222222211111111110000000000
18292                                                  10987654321098765432109876543210
18293                                                  0x001110xx0xxxxxxxx000xxxxxxxxxx
18294                                                  tbl.  */
18295                                               return 420;
18296                                             }
18297                                           else
18298                                             {
18299                                               /* 33222222222211111111110000000000
18300                                                  10987654321098765432109876543210
18301                                                  0x001110xx0xxxxxxxx100xxxxxxxxxx
18302                                                  tbx.  */
18303                                               return 421;
18304                                             }
18305                                         }
18306                                       else
18307                                         {
18308                                           if (((word >> 12) & 0x1) == 0)
18309                                             {
18310                                               if (((word >> 14) & 0x1) == 0)
18311                                                 {
18312                                                   /* 33222222222211111111110000000000
18313                                                      10987654321098765432109876543210
18314                                                      0x001110xx0xxxxxx0x010xxxxxxxxxx
18315                                                      trn1.  */
18316                                                   return 263;
18317                                                 }
18318                                               else
18319                                                 {
18320                                                   /* 33222222222211111111110000000000
18321                                                      10987654321098765432109876543210
18322                                                      0x001110xx0xxxxxx1x010xxxxxxxxxx
18323                                                      trn2.  */
18324                                                   return 266;
18325                                                 }
18326                                             }
18327                                           else
18328                                             {
18329                                               if (((word >> 13) & 0x1) == 0)
18330                                                 {
18331                                                   if (((word >> 14) & 0x1) == 0)
18332                                                     {
18333                                                       /* 33222222222211111111110000000000
18334                                                          10987654321098765432109876543210
18335                                                          0x001110xx0xxxxxx00110xxxxxxxxxx
18336                                                          uzp1.  */
18337                                                       return 262;
18338                                                     }
18339                                                   else
18340                                                     {
18341                                                       /* 33222222222211111111110000000000
18342                                                          10987654321098765432109876543210
18343                                                          0x001110xx0xxxxxx10110xxxxxxxxxx
18344                                                          uzp2.  */
18345                                                       return 265;
18346                                                     }
18347                                                 }
18348                                               else
18349                                                 {
18350                                                   if (((word >> 14) & 0x1) == 0)
18351                                                     {
18352                                                       /* 33222222222211111111110000000000
18353                                                          10987654321098765432109876543210
18354                                                          0x001110xx0xxxxxx01110xxxxxxxxxx
18355                                                          zip1.  */
18356                                                       return 264;
18357                                                     }
18358                                                   else
18359                                                     {
18360                                                       /* 33222222222211111111110000000000
18361                                                          10987654321098765432109876543210
18362                                                          0x001110xx0xxxxxx11110xxxxxxxxxx
18363                                                          zip2.  */
18364                                                       return 267;
18365                                                     }
18366                                                 }
18367                                             }
18368                                         }
18369                                     }
18370                                   else
18371                                     {
18372                                       if (((word >> 11) & 0x1) == 0)
18373                                         {
18374                                           if (((word >> 12) & 0x1) == 0)
18375                                             {
18376                                               if (((word >> 13) & 0x1) == 0)
18377                                                 {
18378                                                   if (((word >> 22) & 0x1) == 0)
18379                                                     {
18380                                                       /* 33222222222211111111110000000000
18381                                                          10987654321098765432109876543210
18382                                                          0x001110x00xxxxxxx0001xxxxxxxxxx
18383                                                          dup.  */
18384                                                       return 149;
18385                                                     }
18386                                                   else
18387                                                     {
18388                                                       if (((word >> 23) & 0x1) == 0)
18389                                                         {
18390                                                           /* 33222222222211111111110000000000
18391                                                              10987654321098765432109876543210
18392                                                              0x001110010xxxxxxx0001xxxxxxxxxx
18393                                                              fmaxnm.  */
18394                                                           return 292;
18395                                                         }
18396                                                       else
18397                                                         {
18398                                                           /* 33222222222211111111110000000000
18399                                                              10987654321098765432109876543210
18400                                                              0x001110110xxxxxxx0001xxxxxxxxxx
18401                                                              fminnm.  */
18402                                                           return 308;
18403                                                         }
18404                                                     }
18405                                                 }
18406                                               else
18407                                                 {
18408                                                   if (((word >> 15) & 0x1) == 0)
18409                                                     {
18410                                                       /* 33222222222211111111110000000000
18411                                                          10987654321098765432109876543210
18412                                                          0x001110xx0xxxxx0x1001xxxxxxxxxx
18413                                                          fcmeq.  */
18414                                                       return 300;
18415                                                     }
18416                                                   else
18417                                                     {
18418                                                       /* 33222222222211111111110000000000
18419                                                          10987654321098765432109876543210
18420                                                          0x001110xx0xxxxx1x1001xxxxxxxxxx
18421                                                          smmla.  */
18422                                                       return 2490;
18423                                                     }
18424                                                 }
18425                                             }
18426                                           else
18427                                             {
18428                                               if (((word >> 13) & 0x1) == 0)
18429                                                 {
18430                                                   if (((word >> 15) & 0x1) == 0)
18431                                                     {
18432                                                       if (((word >> 23) & 0x1) == 0)
18433                                                         {
18434                                                           /* 33222222222211111111110000000000
18435                                                              10987654321098765432109876543210
18436                                                              0x0011100x0xxxxx0x0101xxxxxxxxxx
18437                                                              fadd.  */
18438                                                           return 296;
18439                                                         }
18440                                                       else
18441                                                         {
18442                                                           /* 33222222222211111111110000000000
18443                                                              10987654321098765432109876543210
18444                                                              0x0011101x0xxxxx0x0101xxxxxxxxxx
18445                                                              fsub.  */
18446                                                           return 312;
18447                                                         }
18448                                                     }
18449                                                   else
18450                                                     {
18451                                                       /* 33222222222211111111110000000000
18452                                                          10987654321098765432109876543210
18453                                                          0x001110xx0xxxxx1x0101xxxxxxxxxx
18454                                                          sdot.  */
18455                                                       return 2416;
18456                                                     }
18457                                                 }
18458                                               else
18459                                                 {
18460                                                   if (((word >> 23) & 0x1) == 0)
18461                                                     {
18462                                                       /* 33222222222211111111110000000000
18463                                                          10987654321098765432109876543210
18464                                                          0x0011100x0xxxxxxx1101xxxxxxxxxx
18465                                                          fmax.  */
18466                                                       return 302;
18467                                                     }
18468                                                   else
18469                                                     {
18470                                                       /* 33222222222211111111110000000000
18471                                                          10987654321098765432109876543210
18472                                                          0x0011101x0xxxxxxx1101xxxxxxxxxx
18473                                                          fmin.  */
18474                                                       return 314;
18475                                                     }
18476                                                 }
18477                                             }
18478                                         }
18479                                       else
18480                                         {
18481                                           if (((word >> 12) & 0x1) == 0)
18482                                             {
18483                                               if (((word >> 13) & 0x1) == 0)
18484                                                 {
18485                                                   if (((word >> 22) & 0x1) == 0)
18486                                                     {
18487                                                       /* 33222222222211111111110000000000
18488                                                          10987654321098765432109876543210
18489                                                          0x001110x00xxxxxxx0011xxxxxxxxxx
18490                                                          dup.  */
18491                                                       return 150;
18492                                                     }
18493                                                   else
18494                                                     {
18495                                                       if (((word >> 23) & 0x1) == 0)
18496                                                         {
18497                                                           /* 33222222222211111111110000000000
18498                                                              10987654321098765432109876543210
18499                                                              0x001110010xxxxxxx0011xxxxxxxxxx
18500                                                              fmla.  */
18501                                                           return 294;
18502                                                         }
18503                                                       else
18504                                                         {
18505                                                           /* 33222222222211111111110000000000
18506                                                              10987654321098765432109876543210
18507                                                              0x001110110xxxxxxx0011xxxxxxxxxx
18508                                                              fmls.  */
18509                                                           return 310;
18510                                                         }
18511                                                     }
18512                                                 }
18513                                               else
18514                                                 {
18515                                                   if (((word >> 15) & 0x1) == 0)
18516                                                     {
18517                                                       /* 33222222222211111111110000000000
18518                                                          10987654321098765432109876543210
18519                                                          0x001110xx0xxxxx0x1011xxxxxxxxxx
18520                                                          smov.  */
18521                                                       return 151;
18522                                                     }
18523                                                   else
18524                                                     {
18525                                                       /* 33222222222211111111110000000000
18526                                                          10987654321098765432109876543210
18527                                                          0x001110xx0xxxxx1x1011xxxxxxxxxx
18528                                                          usmmla.  */
18529                                                       return 2492;
18530                                                     }
18531                                                 }
18532                                             }
18533                                           else
18534                                             {
18535                                               if (((word >> 13) & 0x1) == 0)
18536                                                 {
18537                                                   if (((word >> 15) & 0x1) == 0)
18538                                                     {
18539                                                       if (((word >> 22) & 0x1) == 0)
18540                                                         {
18541                                                           /* 33222222222211111111110000000000
18542                                                              10987654321098765432109876543210
18543                                                              0x001110x00xxxxx0x0111xxxxxxxxxx
18544                                                              ins.  */
18545                                                           return 154;
18546                                                         }
18547                                                       else
18548                                                         {
18549                                                           /* 33222222222211111111110000000000
18550                                                              10987654321098765432109876543210
18551                                                              0x001110x10xxxxx0x0111xxxxxxxxxx
18552                                                              fmulx.  */
18553                                                           return 298;
18554                                                         }
18555                                                     }
18556                                                   else
18557                                                     {
18558                                                       /* 33222222222211111111110000000000
18559                                                          10987654321098765432109876543210
18560                                                          0x001110xx0xxxxx1x0111xxxxxxxxxx
18561                                                          usdot.  */
18562                                                       return 2493;
18563                                                     }
18564                                                 }
18565                                               else
18566                                                 {
18567                                                   if (((word >> 22) & 0x1) == 0)
18568                                                     {
18569                                                       /* 33222222222211111111110000000000
18570                                                          10987654321098765432109876543210
18571                                                          0x001110x00xxxxxxx1111xxxxxxxxxx
18572                                                          umov.  */
18573                                                       return 152;
18574                                                     }
18575                                                   else
18576                                                     {
18577                                                       if (((word >> 23) & 0x1) == 0)
18578                                                         {
18579                                                           /* 33222222222211111111110000000000
18580                                                              10987654321098765432109876543210
18581                                                              0x001110010xxxxxxx1111xxxxxxxxxx
18582                                                              frecps.  */
18583                                                           return 304;
18584                                                         }
18585                                                       else
18586                                                         {
18587                                                           /* 33222222222211111111110000000000
18588                                                              10987654321098765432109876543210
18589                                                              0x001110110xxxxxxx1111xxxxxxxxxx
18590                                                              frsqrts.  */
18591                                                           return 316;
18592                                                         }
18593                                                     }
18594                                                 }
18595                                             }
18596                                         }
18597                                     }
18598                                 }
18599                               else
18600                                 {
18601                                   if (((word >> 22) & 0x1) == 0)
18602                                     {
18603                                       if (((word >> 23) & 0x1) == 0)
18604                                         {
18605                                           /* 33222222222211111111110000000000
18606                                              10987654321098765432109876543210
18607                                              1x001110000xxxxxxxxxxxxxxxxxxxxx
18608                                              eor3.  */
18609                                           return 2423;
18610                                         }
18611                                       else
18612                                         {
18613                                           /* 33222222222211111111110000000000
18614                                              10987654321098765432109876543210
18615                                              1x001110100xxxxxxxxxxxxxxxxxxxxx
18616                                              xar.  */
18617                                           return 2425;
18618                                         }
18619                                     }
18620                                   else
18621                                     {
18622                                       if (((word >> 15) & 0x1) == 0)
18623                                         {
18624                                           /* 33222222222211111111110000000000
18625                                              10987654321098765432109876543210
18626                                              1x001110x10xxxxx0xxxxxxxxxxxxxxx
18627                                              sm3ss1.  */
18628                                           return 2427;
18629                                         }
18630                                       else
18631                                         {
18632                                           if (((word >> 10) & 0x1) == 0)
18633                                             {
18634                                               if (((word >> 11) & 0x1) == 0)
18635                                                 {
18636                                                   if (((word >> 23) & 0x1) == 0)
18637                                                     {
18638                                                       /* 33222222222211111111110000000000
18639                                                          10987654321098765432109876543210
18640                                                          1x001110010xxxxx1xxx00xxxxxxxxxx
18641                                                          sm3tt1a.  */
18642                                                       return 2428;
18643                                                     }
18644                                                   else
18645                                                     {
18646                                                       /* 33222222222211111111110000000000
18647                                                          10987654321098765432109876543210
18648                                                          1x001110110xxxxx1xxx00xxxxxxxxxx
18649                                                          sha512su0.  */
18650                                                       return 2421;
18651                                                     }
18652                                                 }
18653                                               else
18654                                                 {
18655                                                   /* 33222222222211111111110000000000
18656                                                      10987654321098765432109876543210
18657                                                      1x001110x10xxxxx1xxx10xxxxxxxxxx
18658                                                      sm3tt2a.  */
18659                                                   return 2430;
18660                                                 }
18661                                             }
18662                                           else
18663                                             {
18664                                               if (((word >> 11) & 0x1) == 0)
18665                                                 {
18666                                                   if (((word >> 23) & 0x1) == 0)
18667                                                     {
18668                                                       /* 33222222222211111111110000000000
18669                                                          10987654321098765432109876543210
18670                                                          1x001110010xxxxx1xxx01xxxxxxxxxx
18671                                                          sm3tt1b.  */
18672                                                       return 2429;
18673                                                     }
18674                                                   else
18675                                                     {
18676                                                       /* 33222222222211111111110000000000
18677                                                          10987654321098765432109876543210
18678                                                          1x001110110xxxxx1xxx01xxxxxxxxxx
18679                                                          sm4e.  */
18680                                                       return 2434;
18681                                                     }
18682                                                 }
18683                                               else
18684                                                 {
18685                                                   /* 33222222222211111111110000000000
18686                                                      10987654321098765432109876543210
18687                                                      1x001110x10xxxxx1xxx11xxxxxxxxxx
18688                                                      sm3tt2b.  */
18689                                                   return 2431;
18690                                                 }
18691                                             }
18692                                         }
18693                                     }
18694                                 }
18695                             }
18696                           else
18697                             {
18698                               if (((word >> 10) & 0x1) == 0)
18699                                 {
18700                                   /* 33222222222211111111110000000000
18701                                      10987654321098765432109876543210
18702                                      xx101110xx0xxxxxxxxxx0xxxxxxxxxx
18703                                      ext.  */
18704                                   return 132;
18705                                 }
18706                               else
18707                                 {
18708                                   if (((word >> 15) & 0x1) == 0)
18709                                     {
18710                                       if (((word >> 22) & 0x1) == 0)
18711                                         {
18712                                           /* 33222222222211111111110000000000
18713                                              10987654321098765432109876543210
18714                                              xx101110x00xxxxx0xxxx1xxxxxxxxxx
18715                                              ins.  */
18716                                           return 156;
18717                                         }
18718                                       else
18719                                         {
18720                                           if (((word >> 11) & 0x1) == 0)
18721                                             {
18722                                               if (((word >> 12) & 0x1) == 0)
18723                                                 {
18724                                                   if (((word >> 13) & 0x1) == 0)
18725                                                     {
18726                                                       if (((word >> 23) & 0x1) == 0)
18727                                                         {
18728                                                           /* 33222222222211111111110000000000
18729                                                              10987654321098765432109876543210
18730                                                              xx101110010xxxxx0x0001xxxxxxxxxx
18731                                                              fmaxnmp.  */
18732                                                           return 343;
18733                                                         }
18734                                                       else
18735                                                         {
18736                                                           /* 33222222222211111111110000000000
18737                                                              10987654321098765432109876543210
18738                                                              xx101110110xxxxx0x0001xxxxxxxxxx
18739                                                              fminnmp.  */
18740                                                           return 359;
18741                                                         }
18742                                                     }
18743                                                   else
18744                                                     {
18745                                                       if (((word >> 23) & 0x1) == 0)
18746                                                         {
18747                                                           /* 33222222222211111111110000000000
18748                                                              10987654321098765432109876543210
18749                                                              xx101110010xxxxx0x1001xxxxxxxxxx
18750                                                              fcmge.  */
18751                                                           return 349;
18752                                                         }
18753                                                       else
18754                                                         {
18755                                                           /* 33222222222211111111110000000000
18756                                                              10987654321098765432109876543210
18757                                                              xx101110110xxxxx0x1001xxxxxxxxxx
18758                                                              fcmgt.  */
18759                                                           return 363;
18760                                                         }
18761                                                     }
18762                                                 }
18763                                               else
18764                                                 {
18765                                                   if (((word >> 13) & 0x1) == 0)
18766                                                     {
18767                                                       if (((word >> 23) & 0x1) == 0)
18768                                                         {
18769                                                           /* 33222222222211111111110000000000
18770                                                              10987654321098765432109876543210
18771                                                              xx101110010xxxxx0x0101xxxxxxxxxx
18772                                                              faddp.  */
18773                                                           return 345;
18774                                                         }
18775                                                       else
18776                                                         {
18777                                                           /* 33222222222211111111110000000000
18778                                                              10987654321098765432109876543210
18779                                                              xx101110110xxxxx0x0101xxxxxxxxxx
18780                                                              fabd.  */
18781                                                           return 361;
18782                                                         }
18783                                                     }
18784                                                   else
18785                                                     {
18786                                                       if (((word >> 23) & 0x1) == 0)
18787                                                         {
18788                                                           /* 33222222222211111111110000000000
18789                                                              10987654321098765432109876543210
18790                                                              xx101110010xxxxx0x1101xxxxxxxxxx
18791                                                              fmaxp.  */
18792                                                           return 353;
18793                                                         }
18794                                                       else
18795                                                         {
18796                                                           /* 33222222222211111111110000000000
18797                                                              10987654321098765432109876543210
18798                                                              xx101110110xxxxx0x1101xxxxxxxxxx
18799                                                              fminp.  */
18800                                                           return 367;
18801                                                         }
18802                                                     }
18803                                                 }
18804                                             }
18805                                           else
18806                                             {
18807                                               if (((word >> 12) & 0x1) == 0)
18808                                                 {
18809                                                   if (((word >> 23) & 0x1) == 0)
18810                                                     {
18811                                                       /* 33222222222211111111110000000000
18812                                                          10987654321098765432109876543210
18813                                                          xx101110010xxxxx0xx011xxxxxxxxxx
18814                                                          facge.  */
18815                                                       return 351;
18816                                                     }
18817                                                   else
18818                                                     {
18819                                                       /* 33222222222211111111110000000000
18820                                                          10987654321098765432109876543210
18821                                                          xx101110110xxxxx0xx011xxxxxxxxxx
18822                                                          facgt.  */
18823                                                       return 365;
18824                                                     }
18825                                                 }
18826                                               else
18827                                                 {
18828                                                   if (((word >> 13) & 0x1) == 0)
18829                                                     {
18830                                                       /* 33222222222211111111110000000000
18831                                                          10987654321098765432109876543210
18832                                                          xx101110x10xxxxx0x0111xxxxxxxxxx
18833                                                          fmul.  */
18834                                                       return 347;
18835                                                     }
18836                                                   else
18837                                                     {
18838                                                       /* 33222222222211111111110000000000
18839                                                          10987654321098765432109876543210
18840                                                          xx101110x10xxxxx0x1111xxxxxxxxxx
18841                                                          fdiv.  */
18842                                                       return 355;
18843                                                     }
18844                                                 }
18845                                             }
18846                                         }
18847                                     }
18848                                   else
18849                                     {
18850                                       if (((word >> 13) & 0x1) == 0)
18851                                         {
18852                                           if (((word >> 14) & 0x1) == 0)
18853                                             {
18854                                               if (((word >> 11) & 0x1) == 0)
18855                                                 {
18856                                                   if (((word >> 12) & 0x1) == 0)
18857                                                     {
18858                                                       /* 33222222222211111111110000000000
18859                                                          10987654321098765432109876543210
18860                                                          xx101110xx0xxxxx100001xxxxxxxxxx
18861                                                          sqrdmlah.  */
18862                                                       return 370;
18863                                                     }
18864                                                   else
18865                                                     {
18866                                                       /* 33222222222211111111110000000000
18867                                                          10987654321098765432109876543210
18868                                                          xx101110xx0xxxxx100101xxxxxxxxxx
18869                                                          udot.  */
18870                                                       return 2415;
18871                                                     }
18872                                                 }
18873                                               else
18874                                                 {
18875                                                   /* 33222222222211111111110000000000
18876                                                      10987654321098765432109876543210
18877                                                      xx101110xx0xxxxx100x11xxxxxxxxxx
18878                                                      sqrdmlsh.  */
18879                                                   return 371;
18880                                                 }
18881                                             }
18882                                           else
18883                                             {
18884                                               /* 33222222222211111111110000000000
18885                                                  10987654321098765432109876543210
18886                                                  xx101110xx0xxxxx110xx1xxxxxxxxxx
18887                                                  fcmla.  */
18888                                               return 372;
18889                                             }
18890                                         }
18891                                       else
18892                                         {
18893                                           if (((word >> 11) & 0x1) == 0)
18894                                             {
18895                                               if (((word >> 14) & 0x1) == 0)
18896                                                 {
18897                                                   /* 33222222222211111111110000000000
18898                                                      10987654321098765432109876543210
18899                                                      xx101110xx0xxxxx101x01xxxxxxxxxx
18900                                                      ummla.  */
18901                                                   return 2491;
18902                                                 }
18903                                               else
18904                                                 {
18905                                                   /* 33222222222211111111110000000000
18906                                                      10987654321098765432109876543210
18907                                                      xx101110xx0xxxxx111x01xxxxxxxxxx
18908                                                      fcadd.  */
18909                                                   return 373;
18910                                                 }
18911                                             }
18912                                           else
18913                                             {
18914                                               if (((word >> 12) & 0x1) == 0)
18915                                                 {
18916                                                   /* 33222222222211111111110000000000
18917                                                      10987654321098765432109876543210
18918                                                      xx101110xx0xxxxx1x1011xxxxxxxxxx
18919                                                      bfmmla.  */
18920                                                   return 2507;
18921                                                 }
18922                                               else
18923                                                 {
18924                                                   if (((word >> 23) & 0x1) == 0)
18925                                                     {
18926                                                       /* 33222222222211111111110000000000
18927                                                          10987654321098765432109876543210
18928                                                          xx1011100x0xxxxx1x1111xxxxxxxxxx
18929                                                          bfdot.  */
18930                                                       return 2505;
18931                                                     }
18932                                                   else
18933                                                     {
18934                                                       if (((word >> 30) & 0x1) == 0)
18935                                                         {
18936                                                           /* 33222222222211111111110000000000
18937                                                              10987654321098765432109876543210
18938                                                              x01011101x0xxxxx1x1111xxxxxxxxxx
18939                                                              bfmlalb.  */
18940                                                           return 2512;
18941                                                         }
18942                                                       else
18943                                                         {
18944                                                           /* 33222222222211111111110000000000
18945                                                              10987654321098765432109876543210
18946                                                              x11011101x0xxxxx1x1111xxxxxxxxxx
18947                                                              bfmlalt.  */
18948                                                           return 2511;
18949                                                         }
18950                                                     }
18951                                                 }
18952                                             }
18953                                         }
18954                                     }
18955                                 }
18956                             }
18957                         }
18958                       else
18959                         {
18960                           if (((word >> 29) & 0x1) == 0)
18961                             {
18962                               if (((word >> 30) & 0x1) == 0)
18963                                 {
18964                                   if (((word >> 16) & 0x1) == 0)
18965                                     {
18966                                       if (((word >> 17) & 0x1) == 0)
18967                                         {
18968                                           /* 33222222222211111111110000000000
18969                                              10987654321098765432109876543210
18970                                              x0011110xx0xxx00xxxxxxxxxxxxxxxx
18971                                              fcvtzs.  */
18972                                           return 764;
18973                                         }
18974                                       else
18975                                         {
18976                                           /* 33222222222211111111110000000000
18977                                              10987654321098765432109876543210
18978                                              x0011110xx0xxx10xxxxxxxxxxxxxxxx
18979                                              scvtf.  */
18980                                           return 760;
18981                                         }
18982                                     }
18983                                   else
18984                                     {
18985                                       if (((word >> 17) & 0x1) == 0)
18986                                         {
18987                                           /* 33222222222211111111110000000000
18988                                              10987654321098765432109876543210
18989                                              x0011110xx0xxx01xxxxxxxxxxxxxxxx
18990                                              fcvtzu.  */
18991                                           return 766;
18992                                         }
18993                                       else
18994                                         {
18995                                           /* 33222222222211111111110000000000
18996                                              10987654321098765432109876543210
18997                                              x0011110xx0xxx11xxxxxxxxxxxxxxxx
18998                                              ucvtf.  */
18999                                           return 762;
19000                                         }
19001                                     }
19002                                 }
19003                               else
19004                                 {
19005                                   if (((word >> 10) & 0x1) == 0)
19006                                     {
19007                                       if (((word >> 12) & 0x1) == 0)
19008                                         {
19009                                           if (((word >> 13) & 0x1) == 0)
19010                                             {
19011                                               if (((word >> 14) & 0x1) == 0)
19012                                                 {
19013                                                   /* 33222222222211111111110000000000
19014                                                      10987654321098765432109876543210
19015                                                      x1011110xx0xxxxxx000x0xxxxxxxxxx
19016                                                      sha1c.  */
19017                                                   return 678;
19018                                                 }
19019                                               else
19020                                                 {
19021                                                   /* 33222222222211111111110000000000
19022                                                      10987654321098765432109876543210
19023                                                      x1011110xx0xxxxxx100x0xxxxxxxxxx
19024                                                      sha256h.  */
19025                                                   return 682;
19026                                                 }
19027                                             }
19028                                           else
19029                                             {
19030                                               if (((word >> 14) & 0x1) == 0)
19031                                                 {
19032                                                   /* 33222222222211111111110000000000
19033                                                      10987654321098765432109876543210
19034                                                      x1011110xx0xxxxxx010x0xxxxxxxxxx
19035                                                      sha1m.  */
19036                                                   return 680;
19037                                                 }
19038                                               else
19039                                                 {
19040                                                   /* 33222222222211111111110000000000
19041                                                      10987654321098765432109876543210
19042                                                      x1011110xx0xxxxxx110x0xxxxxxxxxx
19043                                                      sha256su1.  */
19044                                                   return 684;
19045                                                 }
19046                                             }
19047                                         }
19048                                       else
19049                                         {
19050                                           if (((word >> 13) & 0x1) == 0)
19051                                             {
19052                                               if (((word >> 14) & 0x1) == 0)
19053                                                 {
19054                                                   /* 33222222222211111111110000000000
19055                                                      10987654321098765432109876543210
19056                                                      x1011110xx0xxxxxx001x0xxxxxxxxxx
19057                                                      sha1p.  */
19058                                                   return 679;
19059                                                 }
19060                                               else
19061                                                 {
19062                                                   /* 33222222222211111111110000000000
19063                                                      10987654321098765432109876543210
19064                                                      x1011110xx0xxxxxx101x0xxxxxxxxxx
19065                                                      sha256h2.  */
19066                                                   return 683;
19067                                                 }
19068                                             }
19069                                           else
19070                                             {
19071                                               /* 33222222222211111111110000000000
19072                                                  10987654321098765432109876543210
19073                                                  x1011110xx0xxxxxxx11x0xxxxxxxxxx
19074                                                  sha1su0.  */
19075                                               return 681;
19076                                             }
19077                                         }
19078                                     }
19079                                   else
19080                                     {
19081                                       if (((word >> 11) & 0x1) == 0)
19082                                         {
19083                                           if (((word >> 13) & 0x1) == 0)
19084                                             {
19085                                               /* 33222222222211111111110000000000
19086                                                  10987654321098765432109876543210
19087                                                  x1011110xx0xxxxxxx0x01xxxxxxxxxx
19088                                                  dup.  */
19089                                               return 535;
19090                                             }
19091                                           else
19092                                             {
19093                                               /* 33222222222211111111110000000000
19094                                                  10987654321098765432109876543210
19095                                                  x1011110xx0xxxxxxx1x01xxxxxxxxxx
19096                                                  fcmeq.  */
19097                                               return 556;
19098                                             }
19099                                         }
19100                                       else
19101                                         {
19102                                           if (((word >> 13) & 0x1) == 0)
19103                                             {
19104                                               /* 33222222222211111111110000000000
19105                                                  10987654321098765432109876543210
19106                                                  x1011110xx0xxxxxxx0x11xxxxxxxxxx
19107                                                  fmulx.  */
19108                                               return 554;
19109                                             }
19110                                           else
19111                                             {
19112                                               if (((word >> 23) & 0x1) == 0)
19113                                                 {
19114                                                   /* 33222222222211111111110000000000
19115                                                      10987654321098765432109876543210
19116                                                      x10111100x0xxxxxxx1x11xxxxxxxxxx
19117                                                      frecps.  */
19118                                                   return 558;
19119                                                 }
19120                                               else
19121                                                 {
19122                                                   /* 33222222222211111111110000000000
19123                                                      10987654321098765432109876543210
19124                                                      x10111101x0xxxxxxx1x11xxxxxxxxxx
19125                                                      frsqrts.  */
19126                                                   return 560;
19127                                                 }
19128                                             }
19129                                         }
19130                                     }
19131                                 }
19132                             }
19133                           else
19134                             {
19135                               if (((word >> 11) & 0x1) == 0)
19136                                 {
19137                                   if (((word >> 12) & 0x1) == 0)
19138                                     {
19139                                       if (((word >> 13) & 0x1) == 0)
19140                                         {
19141                                           /* 33222222222211111111110000000000
19142                                              10987654321098765432109876543210
19143                                              xx111110xx0xxxxxxx000xxxxxxxxxxx
19144                                              sqrdmlah.  */
19145                                           return 588;
19146                                         }
19147                                       else
19148                                         {
19149                                           if (((word >> 23) & 0x1) == 0)
19150                                             {
19151                                               /* 33222222222211111111110000000000
19152                                                  10987654321098765432109876543210
19153                                                  xx1111100x0xxxxxxx100xxxxxxxxxxx
19154                                                  fcmge.  */
19155                                               return 573;
19156                                             }
19157                                           else
19158                                             {
19159                                               /* 33222222222211111111110000000000
19160                                                  10987654321098765432109876543210
19161                                                  xx1111101x0xxxxxxx100xxxxxxxxxxx
19162                                                  fcmgt.  */
19163                                               return 579;
19164                                             }
19165                                         }
19166                                     }
19167                                   else
19168                                     {
19169                                       /* 33222222222211111111110000000000
19170                                          10987654321098765432109876543210
19171                                          xx111110xx0xxxxxxxx10xxxxxxxxxxx
19172                                          fabd.  */
19173                                       return 577;
19174                                     }
19175                                 }
19176                               else
19177                                 {
19178                                   if (((word >> 13) & 0x1) == 0)
19179                                     {
19180                                       /* 33222222222211111111110000000000
19181                                          10987654321098765432109876543210
19182                                          xx111110xx0xxxxxxx0x1xxxxxxxxxxx
19183                                          sqrdmlsh.  */
19184                                       return 589;
19185                                     }
19186                                   else
19187                                     {
19188                                       if (((word >> 23) & 0x1) == 0)
19189                                         {
19190                                           /* 33222222222211111111110000000000
19191                                              10987654321098765432109876543210
19192                                              xx1111100x0xxxxxxx1x1xxxxxxxxxxx
19193                                              facge.  */
19194                                           return 575;
19195                                         }
19196                                       else
19197                                         {
19198                                           /* 33222222222211111111110000000000
19199                                              10987654321098765432109876543210
19200                                              xx1111101x0xxxxxxx1x1xxxxxxxxxxx
19201                                              facgt.  */
19202                                           return 581;
19203                                         }
19204                                     }
19205                                 }
19206                             }
19207                         }
19208                     }
19209                   else
19210                     {
19211                       if (((word >> 28) & 0x1) == 0)
19212                         {
19213                           if (((word >> 15) & 0x1) == 0)
19214                             {
19215                               if (((word >> 29) & 0x1) == 0)
19216                                 {
19217                                   if (((word >> 31) & 0x1) == 0)
19218                                     {
19219                                       if (((word >> 10) & 0x1) == 0)
19220                                         {
19221                                           if (((word >> 11) & 0x1) == 0)
19222                                             {
19223                                               if (((word >> 12) & 0x1) == 0)
19224                                                 {
19225                                                   if (((word >> 13) & 0x1) == 0)
19226                                                     {
19227                                                       if (((word >> 14) & 0x1) == 0)
19228                                                         {
19229                                                           if (((word >> 30) & 0x1) == 0)
19230                                                             {
19231                                                               /* 33222222222211111111110000000000
19232                                                                  10987654321098765432109876543210
19233                                                                  00001110xx1xxxxx000000xxxxxxxxxx
19234                                                                  saddl.  */
19235                                                               return 44;
19236                                                             }
19237                                                           else
19238                                                             {
19239                                                               /* 33222222222211111111110000000000
19240                                                                  10987654321098765432109876543210
19241                                                                  01001110xx1xxxxx000000xxxxxxxxxx
19242                                                                  saddl2.  */
19243                                                               return 45;
19244                                                             }
19245                                                         }
19246                                                       else
19247                                                         {
19248                                                           if (((word >> 30) & 0x1) == 0)
19249                                                             {
19250                                                               /* 33222222222211111111110000000000
19251                                                                  10987654321098765432109876543210
19252                                                                  00001110xx1xxxxx010000xxxxxxxxxx
19253                                                                  addhn.  */
19254                                                               return 52;
19255                                                             }
19256                                                           else
19257                                                             {
19258                                                               /* 33222222222211111111110000000000
19259                                                                  10987654321098765432109876543210
19260                                                                  01001110xx1xxxxx010000xxxxxxxxxx
19261                                                                  addhn2.  */
19262                                                               return 53;
19263                                                             }
19264                                                         }
19265                                                     }
19266                                                   else
19267                                                     {
19268                                                       if (((word >> 14) & 0x1) == 0)
19269                                                         {
19270                                                           if (((word >> 30) & 0x1) == 0)
19271                                                             {
19272                                                               /* 33222222222211111111110000000000
19273                                                                  10987654321098765432109876543210
19274                                                                  00001110xx1xxxxx001000xxxxxxxxxx
19275                                                                  ssubl.  */
19276                                                               return 48;
19277                                                             }
19278                                                           else
19279                                                             {
19280                                                               /* 33222222222211111111110000000000
19281                                                                  10987654321098765432109876543210
19282                                                                  01001110xx1xxxxx001000xxxxxxxxxx
19283                                                                  ssubl2.  */
19284                                                               return 49;
19285                                                             }
19286                                                         }
19287                                                       else
19288                                                         {
19289                                                           if (((word >> 30) & 0x1) == 0)
19290                                                             {
19291                                                               /* 33222222222211111111110000000000
19292                                                                  10987654321098765432109876543210
19293                                                                  00001110xx1xxxxx011000xxxxxxxxxx
19294                                                                  subhn.  */
19295                                                               return 56;
19296                                                             }
19297                                                           else
19298                                                             {
19299                                                               /* 33222222222211111111110000000000
19300                                                                  10987654321098765432109876543210
19301                                                                  01001110xx1xxxxx011000xxxxxxxxxx
19302                                                                  subhn2.  */
19303                                                               return 57;
19304                                                             }
19305                                                         }
19306                                                     }
19307                                                 }
19308                                               else
19309                                                 {
19310                                                   if (((word >> 13) & 0x1) == 0)
19311                                                     {
19312                                                       if (((word >> 14) & 0x1) == 0)
19313                                                         {
19314                                                           if (((word >> 30) & 0x1) == 0)
19315                                                             {
19316                                                               /* 33222222222211111111110000000000
19317                                                                  10987654321098765432109876543210
19318                                                                  00001110xx1xxxxx000100xxxxxxxxxx
19319                                                                  saddw.  */
19320                                                               return 46;
19321                                                             }
19322                                                           else
19323                                                             {
19324                                                               /* 33222222222211111111110000000000
19325                                                                  10987654321098765432109876543210
19326                                                                  01001110xx1xxxxx000100xxxxxxxxxx
19327                                                                  saddw2.  */
19328                                                               return 47;
19329                                                             }
19330                                                         }
19331                                                       else
19332                                                         {
19333                                                           if (((word >> 30) & 0x1) == 0)
19334                                                             {
19335                                                               /* 33222222222211111111110000000000
19336                                                                  10987654321098765432109876543210
19337                                                                  00001110xx1xxxxx010100xxxxxxxxxx
19338                                                                  sabal.  */
19339                                                               return 54;
19340                                                             }
19341                                                           else
19342                                                             {
19343                                                               /* 33222222222211111111110000000000
19344                                                                  10987654321098765432109876543210
19345                                                                  01001110xx1xxxxx010100xxxxxxxxxx
19346                                                                  sabal2.  */
19347                                                               return 55;
19348                                                             }
19349                                                         }
19350                                                     }
19351                                                   else
19352                                                     {
19353                                                       if (((word >> 14) & 0x1) == 0)
19354                                                         {
19355                                                           if (((word >> 30) & 0x1) == 0)
19356                                                             {
19357                                                               /* 33222222222211111111110000000000
19358                                                                  10987654321098765432109876543210
19359                                                                  00001110xx1xxxxx001100xxxxxxxxxx
19360                                                                  ssubw.  */
19361                                                               return 50;
19362                                                             }
19363                                                           else
19364                                                             {
19365                                                               /* 33222222222211111111110000000000
19366                                                                  10987654321098765432109876543210
19367                                                                  01001110xx1xxxxx001100xxxxxxxxxx
19368                                                                  ssubw2.  */
19369                                                               return 51;
19370                                                             }
19371                                                         }
19372                                                       else
19373                                                         {
19374                                                           if (((word >> 30) & 0x1) == 0)
19375                                                             {
19376                                                               /* 33222222222211111111110000000000
19377                                                                  10987654321098765432109876543210
19378                                                                  00001110xx1xxxxx011100xxxxxxxxxx
19379                                                                  sabdl.  */
19380                                                               return 58;
19381                                                             }
19382                                                           else
19383                                                             {
19384                                                               /* 33222222222211111111110000000000
19385                                                                  10987654321098765432109876543210
19386                                                                  01001110xx1xxxxx011100xxxxxxxxxx
19387                                                                  sabdl2.  */
19388                                                               return 59;
19389                                                             }
19390                                                         }
19391                                                     }
19392                                                 }
19393                                             }
19394                                           else
19395                                             {
19396                                               if (((word >> 12) & 0x1) == 0)
19397                                                 {
19398                                                   if (((word >> 13) & 0x1) == 0)
19399                                                     {
19400                                                       if (((word >> 14) & 0x1) == 0)
19401                                                         {
19402                                                           /* 33222222222211111111110000000000
19403                                                              10987654321098765432109876543210
19404                                                              0x001110xx1xxxxx000010xxxxxxxxxx
19405                                                              rev64.  */
19406                                                           return 162;
19407                                                         }
19408                                                       else
19409                                                         {
19410                                                           if (((word >> 16) & 0x1) == 0)
19411                                                             {
19412                                                               if (((word >> 19) & 0x1) == 0)
19413                                                                 {
19414                                                                   /* 33222222222211111111110000000000
19415                                                                      10987654321098765432109876543210
19416                                                                      0x001110xx1x0xx0010010xxxxxxxxxx
19417                                                                      cls.  */
19418                                                                   return 166;
19419                                                                 }
19420                                                               else
19421                                                                 {
19422                                                                   /* 33222222222211111111110000000000
19423                                                                      10987654321098765432109876543210
19424                                                                      0x001110xx1x1xx0010010xxxxxxxxxx
19425                                                                      aese.  */
19426                                                                   return 671;
19427                                                                 }
19428                                                             }
19429                                                           else
19430                                                             {
19431                                                               if (((word >> 30) & 0x1) == 0)
19432                                                                 {
19433                                                                   /* 33222222222211111111110000000000
19434                                                                      10987654321098765432109876543210
19435                                                                      00001110xx1xxxx1010010xxxxxxxxxx
19436                                                                      sqxtn.  */
19437                                                                   return 176;
19438                                                                 }
19439                                                               else
19440                                                                 {
19441                                                                   /* 33222222222211111111110000000000
19442                                                                      10987654321098765432109876543210
19443                                                                      01001110xx1xxxx1010010xxxxxxxxxx
19444                                                                      sqxtn2.  */
19445                                                                   return 177;
19446                                                                 }
19447                                                             }
19448                                                         }
19449                                                     }
19450                                                   else
19451                                                     {
19452                                                       if (((word >> 14) & 0x1) == 0)
19453                                                         {
19454                                                           if (((word >> 16) & 0x1) == 0)
19455                                                             {
19456                                                               /* 33222222222211111111110000000000
19457                                                                  10987654321098765432109876543210
19458                                                                  0x001110xx1xxxx0001010xxxxxxxxxx
19459                                                                  saddlp.  */
19460                                                               return 164;
19461                                                             }
19462                                                           else
19463                                                             {
19464                                                               if (((word >> 30) & 0x1) == 0)
19465                                                                 {
19466                                                                   /* 33222222222211111111110000000000
19467                                                                      10987654321098765432109876543210
19468                                                                      00001110xx1xxxx1001010xxxxxxxxxx
19469                                                                      xtn.  */
19470                                                                   return 174;
19471                                                                 }
19472                                                               else
19473                                                                 {
19474                                                                   /* 33222222222211111111110000000000
19475                                                                      10987654321098765432109876543210
19476                                                                      01001110xx1xxxx1001010xxxxxxxxxx
19477                                                                      xtn2.  */
19478                                                                   return 175;
19479                                                                 }
19480                                                             }
19481                                                         }
19482                                                       else
19483                                                         {
19484                                                           if (((word >> 16) & 0x1) == 0)
19485                                                             {
19486                                                               if (((word >> 19) & 0x1) == 0)
19487                                                                 {
19488                                                                   /* 33222222222211111111110000000000
19489                                                                      10987654321098765432109876543210
19490                                                                      0x001110xx1x0xx0011010xxxxxxxxxx
19491                                                                      sadalp.  */
19492                                                                   return 168;
19493                                                                 }
19494                                                               else
19495                                                                 {
19496                                                                   /* 33222222222211111111110000000000
19497                                                                      10987654321098765432109876543210
19498                                                                      0x001110xx1x1xx0011010xxxxxxxxxx
19499                                                                      aesmc.  */
19500                                                                   return 673;
19501                                                                 }
19502                                                             }
19503                                                           else
19504                                                             {
19505                                                               if (((word >> 23) & 0x1) == 0)
19506                                                                 {
19507                                                                   if (((word >> 30) & 0x1) == 0)
19508                                                                     {
19509                                                                       /* 33222222222211111111110000000000
19510                                                                          10987654321098765432109876543210
19511                                                                          000011100x1xxxx1011010xxxxxxxxxx
19512                                                                          fcvtn.  */
19513                                                                       return 178;
19514                                                                     }
19515                                                                   else
19516                                                                     {
19517                                                                       /* 33222222222211111111110000000000
19518                                                                          10987654321098765432109876543210
19519                                                                          010011100x1xxxx1011010xxxxxxxxxx
19520                                                                          fcvtn2.  */
19521                                                                       return 179;
19522                                                                     }
19523                                                                 }
19524                                                               else
19525                                                                 {
19526                                                                   if (((word >> 30) & 0x1) == 0)
19527                                                                     {
19528                                                                       /* 33222222222211111111110000000000
19529                                                                          10987654321098765432109876543210
19530                                                                          000011101x1xxxx1011010xxxxxxxxxx
19531                                                                          bfcvtn.  */
19532                                                                       return 2508;
19533                                                                     }
19534                                                                   else
19535                                                                     {
19536                                                                       /* 33222222222211111111110000000000
19537                                                                          10987654321098765432109876543210
19538                                                                          010011101x1xxxx1011010xxxxxxxxxx
19539                                                                          bfcvtn2.  */
19540                                                                       return 2509;
19541                                                                     }
19542                                                                 }
19543                                                             }
19544                                                         }
19545                                                     }
19546                                                 }
19547                                               else
19548                                                 {
19549                                                   if (((word >> 13) & 0x1) == 0)
19550                                                     {
19551                                                       if (((word >> 14) & 0x1) == 0)
19552                                                         {
19553                                                           /* 33222222222211111111110000000000
19554                                                              10987654321098765432109876543210
19555                                                              0x001110xx1xxxxx000110xxxxxxxxxx
19556                                                              rev16.  */
19557                                                           return 163;
19558                                                         }
19559                                                       else
19560                                                         {
19561                                                           if (((word >> 19) & 0x1) == 0)
19562                                                             {
19563                                                               /* 33222222222211111111110000000000
19564                                                                  10987654321098765432109876543210
19565                                                                  0x001110xx1x0xxx010110xxxxxxxxxx
19566                                                                  cnt.  */
19567                                                               return 167;
19568                                                             }
19569                                                           else
19570                                                             {
19571                                                               /* 33222222222211111111110000000000
19572                                                                  10987654321098765432109876543210
19573                                                                  0x001110xx1x1xxx010110xxxxxxxxxx
19574                                                                  aesd.  */
19575                                                               return 672;
19576                                                             }
19577                                                         }
19578                                                     }
19579                                                   else
19580                                                     {
19581                                                       if (((word >> 14) & 0x1) == 0)
19582                                                         {
19583                                                           if (((word >> 20) & 0x1) == 0)
19584                                                             {
19585                                                               /* 33222222222211111111110000000000
19586                                                                  10987654321098765432109876543210
19587                                                                  0x001110xx10xxxx001110xxxxxxxxxx
19588                                                                  suqadd.  */
19589                                                               return 165;
19590                                                             }
19591                                                           else
19592                                                             {
19593                                                               /* 33222222222211111111110000000000
19594                                                                  10987654321098765432109876543210
19595                                                                  0x001110xx11xxxx001110xxxxxxxxxx
19596                                                                  saddlv.  */
19597                                                               return 29;
19598                                                             }
19599                                                         }
19600                                                       else
19601                                                         {
19602                                                           if (((word >> 16) & 0x1) == 0)
19603                                                             {
19604                                                               if (((word >> 19) & 0x1) == 0)
19605                                                                 {
19606                                                                   /* 33222222222211111111110000000000
19607                                                                      10987654321098765432109876543210
19608                                                                      0x001110xx1x0xx0011110xxxxxxxxxx
19609                                                                      sqabs.  */
19610                                                                   return 169;
19611                                                                 }
19612                                                               else
19613                                                                 {
19614                                                                   /* 33222222222211111111110000000000
19615                                                                      10987654321098765432109876543210
19616                                                                      0x001110xx1x1xx0011110xxxxxxxxxx
19617                                                                      aesimc.  */
19618                                                                   return 674;
19619                                                                 }
19620                                                             }
19621                                                           else
19622                                                             {
19623                                                               if (((word >> 30) & 0x1) == 0)
19624                                                                 {
19625                                                                   /* 33222222222211111111110000000000
19626                                                                      10987654321098765432109876543210
19627                                                                      00001110xx1xxxx1011110xxxxxxxxxx
19628                                                                      fcvtl.  */
19629                                                                   return 180;
19630                                                                 }
19631                                                               else
19632                                                                 {
19633                                                                   /* 33222222222211111111110000000000
19634                                                                      10987654321098765432109876543210
19635                                                                      01001110xx1xxxx1011110xxxxxxxxxx
19636                                                                      fcvtl2.  */
19637                                                                   return 181;
19638                                                                 }
19639                                                             }
19640                                                         }
19641                                                     }
19642                                                 }
19643                                             }
19644                                         }
19645                                       else
19646                                         {
19647                                           if (((word >> 11) & 0x1) == 0)
19648                                             {
19649                                               if (((word >> 12) & 0x1) == 0)
19650                                                 {
19651                                                   if (((word >> 13) & 0x1) == 0)
19652                                                     {
19653                                                       if (((word >> 14) & 0x1) == 0)
19654                                                         {
19655                                                           /* 33222222222211111111110000000000
19656                                                              10987654321098765432109876543210
19657                                                              0x001110xx1xxxxx000001xxxxxxxxxx
19658                                                              shadd.  */
19659                                                           return 268;
19660                                                         }
19661                                                       else
19662                                                         {
19663                                                           /* 33222222222211111111110000000000
19664                                                              10987654321098765432109876543210
19665                                                              0x001110xx1xxxxx010001xxxxxxxxxx
19666                                                              sshl.  */
19667                                                           return 275;
19668                                                         }
19669                                                     }
19670                                                   else
19671                                                     {
19672                                                       if (((word >> 14) & 0x1) == 0)
19673                                                         {
19674                                                           /* 33222222222211111111110000000000
19675                                                              10987654321098765432109876543210
19676                                                              0x001110xx1xxxxx001001xxxxxxxxxx
19677                                                              shsub.  */
19678                                                           return 271;
19679                                                         }
19680                                                       else
19681                                                         {
19682                                                           /* 33222222222211111111110000000000
19683                                                              10987654321098765432109876543210
19684                                                              0x001110xx1xxxxx011001xxxxxxxxxx
19685                                                              smax.  */
19686                                                           return 279;
19687                                                         }
19688                                                     }
19689                                                 }
19690                                               else
19691                                                 {
19692                                                   if (((word >> 13) & 0x1) == 0)
19693                                                     {
19694                                                       if (((word >> 14) & 0x1) == 0)
19695                                                         {
19696                                                           /* 33222222222211111111110000000000
19697                                                              10987654321098765432109876543210
19698                                                              0x001110xx1xxxxx000101xxxxxxxxxx
19699                                                              srhadd.  */
19700                                                           return 270;
19701                                                         }
19702                                                       else
19703                                                         {
19704                                                           /* 33222222222211111111110000000000
19705                                                              10987654321098765432109876543210
19706                                                              0x001110xx1xxxxx010101xxxxxxxxxx
19707                                                              srshl.  */
19708                                                           return 277;
19709                                                         }
19710                                                     }
19711                                                   else
19712                                                     {
19713                                                       if (((word >> 14) & 0x1) == 0)
19714                                                         {
19715                                                           /* 33222222222211111111110000000000
19716                                                              10987654321098765432109876543210
19717                                                              0x001110xx1xxxxx001101xxxxxxxxxx
19718                                                              cmgt.  */
19719                                                           return 273;
19720                                                         }
19721                                                       else
19722                                                         {
19723                                                           /* 33222222222211111111110000000000
19724                                                              10987654321098765432109876543210
19725                                                              0x001110xx1xxxxx011101xxxxxxxxxx
19726                                                              sabd.  */
19727                                                           return 281;
19728                                                         }
19729                                                     }
19730                                                 }
19731                                             }
19732                                           else
19733                                             {
19734                                               if (((word >> 12) & 0x1) == 0)
19735                                                 {
19736                                                   if (((word >> 13) & 0x1) == 0)
19737                                                     {
19738                                                       if (((word >> 14) & 0x1) == 0)
19739                                                         {
19740                                                           /* 33222222222211111111110000000000
19741                                                              10987654321098765432109876543210
19742                                                              0x001110xx1xxxxx000011xxxxxxxxxx
19743                                                              sqadd.  */
19744                                                           return 269;
19745                                                         }
19746                                                       else
19747                                                         {
19748                                                           /* 33222222222211111111110000000000
19749                                                              10987654321098765432109876543210
19750                                                              0x001110xx1xxxxx010011xxxxxxxxxx
19751                                                              sqshl.  */
19752                                                           return 276;
19753                                                         }
19754                                                     }
19755                                                   else
19756                                                     {
19757                                                       if (((word >> 14) & 0x1) == 0)
19758                                                         {
19759                                                           /* 33222222222211111111110000000000
19760                                                              10987654321098765432109876543210
19761                                                              0x001110xx1xxxxx001011xxxxxxxxxx
19762                                                              sqsub.  */
19763                                                           return 272;
19764                                                         }
19765                                                       else
19766                                                         {
19767                                                           /* 33222222222211111111110000000000
19768                                                              10987654321098765432109876543210
19769                                                              0x001110xx1xxxxx011011xxxxxxxxxx
19770                                                              smin.  */
19771                                                           return 280;
19772                                                         }
19773                                                     }
19774                                                 }
19775                                               else
19776                                                 {
19777                                                   if (((word >> 13) & 0x1) == 0)
19778                                                     {
19779                                                       if (((word >> 14) & 0x1) == 0)
19780                                                         {
19781                                                           if (((word >> 22) & 0x1) == 0)
19782                                                             {
19783                                                               if (((word >> 23) & 0x1) == 0)
19784                                                                 {
19785                                                                   /* 33222222222211111111110000000000
19786                                                                      10987654321098765432109876543210
19787                                                                      0x001110001xxxxx000111xxxxxxxxxx
19788                                                                      and.  */
19789                                                                   return 305;
19790                                                                 }
19791                                                               else
19792                                                                 {
19793                                                                   /* 33222222222211111111110000000000
19794                                                                      10987654321098765432109876543210
19795                                                                      0x001110101xxxxx000111xxxxxxxxxx
19796                                                                      orr.  */
19797                                                                   return 317;
19798                                                                 }
19799                                                             }
19800                                                           else
19801                                                             {
19802                                                               if (((word >> 23) & 0x1) == 0)
19803                                                                 {
19804                                                                   /* 33222222222211111111110000000000
19805                                                                      10987654321098765432109876543210
19806                                                                      0x001110011xxxxx000111xxxxxxxxxx
19807                                                                      bic.  */
19808                                                                   return 306;
19809                                                                 }
19810                                                               else
19811                                                                 {
19812                                                                   /* 33222222222211111111110000000000
19813                                                                      10987654321098765432109876543210
19814                                                                      0x001110111xxxxx000111xxxxxxxxxx
19815                                                                      orn.  */
19816                                                                   return 319;
19817                                                                 }
19818                                                             }
19819                                                         }
19820                                                       else
19821                                                         {
19822                                                           /* 33222222222211111111110000000000
19823                                                              10987654321098765432109876543210
19824                                                              0x001110xx1xxxxx010111xxxxxxxxxx
19825                                                              sqrshl.  */
19826                                                           return 278;
19827                                                         }
19828                                                     }
19829                                                   else
19830                                                     {
19831                                                       if (((word >> 14) & 0x1) == 0)
19832                                                         {
19833                                                           /* 33222222222211111111110000000000
19834                                                              10987654321098765432109876543210
19835                                                              0x001110xx1xxxxx001111xxxxxxxxxx
19836                                                              cmge.  */
19837                                                           return 274;
19838                                                         }
19839                                                       else
19840                                                         {
19841                                                           /* 33222222222211111111110000000000
19842                                                              10987654321098765432109876543210
19843                                                              0x001110xx1xxxxx011111xxxxxxxxxx
19844                                                              saba.  */
19845                                                           return 282;
19846                                                         }
19847                                                     }
19848                                                 }
19849                                             }
19850                                         }
19851                                     }
19852                                   else
19853                                     {
19854                                       /* 33222222222211111111110000000000
19855                                          10987654321098765432109876543210
19856                                          1x001110xx1xxxxx0xxxxxxxxxxxxxxx
19857                                          bcax.  */
19858                                       return 2426;
19859                                     }
19860                                 }
19861                               else
19862                                 {
19863                                   if (((word >> 10) & 0x1) == 0)
19864                                     {
19865                                       if (((word >> 11) & 0x1) == 0)
19866                                         {
19867                                           if (((word >> 12) & 0x1) == 0)
19868                                             {
19869                                               if (((word >> 13) & 0x1) == 0)
19870                                                 {
19871                                                   if (((word >> 14) & 0x1) == 0)
19872                                                     {
19873                                                       if (((word >> 30) & 0x1) == 0)
19874                                                         {
19875                                                           /* 33222222222211111111110000000000
19876                                                              10987654321098765432109876543210
19877                                                              x0101110xx1xxxxx000000xxxxxxxxxx
19878                                                              uaddl.  */
19879                                                           return 76;
19880                                                         }
19881                                                       else
19882                                                         {
19883                                                           /* 33222222222211111111110000000000
19884                                                              10987654321098765432109876543210
19885                                                              x1101110xx1xxxxx000000xxxxxxxxxx
19886                                                              uaddl2.  */
19887                                                           return 77;
19888                                                         }
19889                                                     }
19890                                                   else
19891                                                     {
19892                                                       if (((word >> 30) & 0x1) == 0)
19893                                                         {
19894                                                           /* 33222222222211111111110000000000
19895                                                              10987654321098765432109876543210
19896                                                              x0101110xx1xxxxx010000xxxxxxxxxx
19897                                                              raddhn.  */
19898                                                           return 84;
19899                                                         }
19900                                                       else
19901                                                         {
19902                                                           /* 33222222222211111111110000000000
19903                                                              10987654321098765432109876543210
19904                                                              x1101110xx1xxxxx010000xxxxxxxxxx
19905                                                              raddhn2.  */
19906                                                           return 85;
19907                                                         }
19908                                                     }
19909                                                 }
19910                                               else
19911                                                 {
19912                                                   if (((word >> 14) & 0x1) == 0)
19913                                                     {
19914                                                       if (((word >> 30) & 0x1) == 0)
19915                                                         {
19916                                                           /* 33222222222211111111110000000000
19917                                                              10987654321098765432109876543210
19918                                                              x0101110xx1xxxxx001000xxxxxxxxxx
19919                                                              usubl.  */
19920                                                           return 80;
19921                                                         }
19922                                                       else
19923                                                         {
19924                                                           /* 33222222222211111111110000000000
19925                                                              10987654321098765432109876543210
19926                                                              x1101110xx1xxxxx001000xxxxxxxxxx
19927                                                              usubl2.  */
19928                                                           return 81;
19929                                                         }
19930                                                     }
19931                                                   else
19932                                                     {
19933                                                       if (((word >> 30) & 0x1) == 0)
19934                                                         {
19935                                                           /* 33222222222211111111110000000000
19936                                                              10987654321098765432109876543210
19937                                                              x0101110xx1xxxxx011000xxxxxxxxxx
19938                                                              rsubhn.  */
19939                                                           return 88;
19940                                                         }
19941                                                       else
19942                                                         {
19943                                                           /* 33222222222211111111110000000000
19944                                                              10987654321098765432109876543210
19945                                                              x1101110xx1xxxxx011000xxxxxxxxxx
19946                                                              rsubhn2.  */
19947                                                           return 89;
19948                                                         }
19949                                                     }
19950                                                 }
19951                                             }
19952                                           else
19953                                             {
19954                                               if (((word >> 13) & 0x1) == 0)
19955                                                 {
19956                                                   if (((word >> 14) & 0x1) == 0)
19957                                                     {
19958                                                       if (((word >> 30) & 0x1) == 0)
19959                                                         {
19960                                                           /* 33222222222211111111110000000000
19961                                                              10987654321098765432109876543210
19962                                                              x0101110xx1xxxxx000100xxxxxxxxxx
19963                                                              uaddw.  */
19964                                                           return 78;
19965                                                         }
19966                                                       else
19967                                                         {
19968                                                           /* 33222222222211111111110000000000
19969                                                              10987654321098765432109876543210
19970                                                              x1101110xx1xxxxx000100xxxxxxxxxx
19971                                                              uaddw2.  */
19972                                                           return 79;
19973                                                         }
19974                                                     }
19975                                                   else
19976                                                     {
19977                                                       if (((word >> 30) & 0x1) == 0)
19978                                                         {
19979                                                           /* 33222222222211111111110000000000
19980                                                              10987654321098765432109876543210
19981                                                              x0101110xx1xxxxx010100xxxxxxxxxx
19982                                                              uabal.  */
19983                                                           return 86;
19984                                                         }
19985                                                       else
19986                                                         {
19987                                                           /* 33222222222211111111110000000000
19988                                                              10987654321098765432109876543210
19989                                                              x1101110xx1xxxxx010100xxxxxxxxxx
19990                                                              uabal2.  */
19991                                                           return 87;
19992                                                         }
19993                                                     }
19994                                                 }
19995                                               else
19996                                                 {
19997                                                   if (((word >> 14) & 0x1) == 0)
19998                                                     {
19999                                                       if (((word >> 30) & 0x1) == 0)
20000                                                         {
20001                                                           /* 33222222222211111111110000000000
20002                                                              10987654321098765432109876543210
20003                                                              x0101110xx1xxxxx001100xxxxxxxxxx
20004                                                              usubw.  */
20005                                                           return 82;
20006                                                         }
20007                                                       else
20008                                                         {
20009                                                           /* 33222222222211111111110000000000
20010                                                              10987654321098765432109876543210
20011                                                              x1101110xx1xxxxx001100xxxxxxxxxx
20012                                                              usubw2.  */
20013                                                           return 83;
20014                                                         }
20015                                                     }
20016                                                   else
20017                                                     {
20018                                                       if (((word >> 30) & 0x1) == 0)
20019                                                         {
20020                                                           /* 33222222222211111111110000000000
20021                                                              10987654321098765432109876543210
20022                                                              x0101110xx1xxxxx011100xxxxxxxxxx
20023                                                              uabdl.  */
20024                                                           return 90;
20025                                                         }
20026                                                       else
20027                                                         {
20028                                                           /* 33222222222211111111110000000000
20029                                                              10987654321098765432109876543210
20030                                                              x1101110xx1xxxxx011100xxxxxxxxxx
20031                                                              uabdl2.  */
20032                                                           return 91;
20033                                                         }
20034                                                     }
20035                                                 }
20036                                             }
20037                                         }
20038                                       else
20039                                         {
20040                                           if (((word >> 12) & 0x1) == 0)
20041                                             {
20042                                               if (((word >> 13) & 0x1) == 0)
20043                                                 {
20044                                                   if (((word >> 14) & 0x1) == 0)
20045                                                     {
20046                                                       /* 33222222222211111111110000000000
20047                                                          10987654321098765432109876543210
20048                                                          xx101110xx1xxxxx000010xxxxxxxxxx
20049                                                          rev32.  */
20050                                                       return 213;
20051                                                     }
20052                                                   else
20053                                                     {
20054                                                       if (((word >> 16) & 0x1) == 0)
20055                                                         {
20056                                                           /* 33222222222211111111110000000000
20057                                                              10987654321098765432109876543210
20058                                                              xx101110xx1xxxx0010010xxxxxxxxxx
20059                                                              clz.  */
20060                                                           return 216;
20061                                                         }
20062                                                       else
20063                                                         {
20064                                                           if (((word >> 30) & 0x1) == 0)
20065                                                             {
20066                                                               /* 33222222222211111111110000000000
20067                                                                  10987654321098765432109876543210
20068                                                                  x0101110xx1xxxx1010010xxxxxxxxxx
20069                                                                  uqxtn.  */
20070                                                               return 226;
20071                                                             }
20072                                                           else
20073                                                             {
20074                                                               /* 33222222222211111111110000000000
20075                                                                  10987654321098765432109876543210
20076                                                                  x1101110xx1xxxx1010010xxxxxxxxxx
20077                                                                  uqxtn2.  */
20078                                                               return 227;
20079                                                             }
20080                                                         }
20081                                                     }
20082                                                 }
20083                                               else
20084                                                 {
20085                                                   if (((word >> 14) & 0x1) == 0)
20086                                                     {
20087                                                       if (((word >> 16) & 0x1) == 0)
20088                                                         {
20089                                                           /* 33222222222211111111110000000000
20090                                                              10987654321098765432109876543210
20091                                                              xx101110xx1xxxx0001010xxxxxxxxxx
20092                                                              uaddlp.  */
20093                                                           return 214;
20094                                                         }
20095                                                       else
20096                                                         {
20097                                                           if (((word >> 30) & 0x1) == 0)
20098                                                             {
20099                                                               /* 33222222222211111111110000000000
20100                                                                  10987654321098765432109876543210
20101                                                                  x0101110xx1xxxx1001010xxxxxxxxxx
20102                                                                  sqxtun.  */
20103                                                               return 222;
20104                                                             }
20105                                                           else
20106                                                             {
20107                                                               /* 33222222222211111111110000000000
20108                                                                  10987654321098765432109876543210
20109                                                                  x1101110xx1xxxx1001010xxxxxxxxxx
20110                                                                  sqxtun2.  */
20111                                                               return 223;
20112                                                             }
20113                                                         }
20114                                                     }
20115                                                   else
20116                                                     {
20117                                                       if (((word >> 16) & 0x1) == 0)
20118                                                         {
20119                                                           /* 33222222222211111111110000000000
20120                                                              10987654321098765432109876543210
20121                                                              xx101110xx1xxxx0011010xxxxxxxxxx
20122                                                              uadalp.  */
20123                                                           return 217;
20124                                                         }
20125                                                       else
20126                                                         {
20127                                                           if (((word >> 30) & 0x1) == 0)
20128                                                             {
20129                                                               /* 33222222222211111111110000000000
20130                                                                  10987654321098765432109876543210
20131                                                                  x0101110xx1xxxx1011010xxxxxxxxxx
20132                                                                  fcvtxn.  */
20133                                                               return 228;
20134                                                             }
20135                                                           else
20136                                                             {
20137                                                               /* 33222222222211111111110000000000
20138                                                                  10987654321098765432109876543210
20139                                                                  x1101110xx1xxxx1011010xxxxxxxxxx
20140                                                                  fcvtxn2.  */
20141                                                               return 229;
20142                                                             }
20143                                                         }
20144                                                     }
20145                                                 }
20146                                             }
20147                                           else
20148                                             {
20149                                               if (((word >> 13) & 0x1) == 0)
20150                                                 {
20151                                                   if (((word >> 22) & 0x1) == 0)
20152                                                     {
20153                                                       /* 33222222222211111111110000000000
20154                                                          10987654321098765432109876543210
20155                                                          xx101110x01xxxxx0x0110xxxxxxxxxx
20156                                                          not.  */
20157                                                       return 242;
20158                                                     }
20159                                                   else
20160                                                     {
20161                                                       /* 33222222222211111111110000000000
20162                                                          10987654321098765432109876543210
20163                                                          xx101110x11xxxxx0x0110xxxxxxxxxx
20164                                                          rbit.  */
20165                                                       return 244;
20166                                                     }
20167                                                 }
20168                                               else
20169                                                 {
20170                                                   if (((word >> 14) & 0x1) == 0)
20171                                                     {
20172                                                       if (((word >> 16) & 0x1) == 0)
20173                                                         {
20174                                                           if (((word >> 20) & 0x1) == 0)
20175                                                             {
20176                                                               /* 33222222222211111111110000000000
20177                                                                  10987654321098765432109876543210
20178                                                                  xx101110xx10xxx0001110xxxxxxxxxx
20179                                                                  usqadd.  */
20180                                                               return 215;
20181                                                             }
20182                                                           else
20183                                                             {
20184                                                               /* 33222222222211111111110000000000
20185                                                                  10987654321098765432109876543210
20186                                                                  xx101110xx11xxx0001110xxxxxxxxxx
20187                                                                  uaddlv.  */
20188                                                               return 33;
20189                                                             }
20190                                                         }
20191                                                       else
20192                                                         {
20193                                                           if (((word >> 30) & 0x1) == 0)
20194                                                             {
20195                                                               /* 33222222222211111111110000000000
20196                                                                  10987654321098765432109876543210
20197                                                                  x0101110xx1xxxx1001110xxxxxxxxxx
20198                                                                  shll.  */
20199                                                               return 224;
20200                                                             }
20201                                                           else
20202                                                             {
20203                                                               /* 33222222222211111111110000000000
20204                                                                  10987654321098765432109876543210
20205                                                                  x1101110xx1xxxx1001110xxxxxxxxxx
20206                                                                  shll2.  */
20207                                                               return 225;
20208                                                             }
20209                                                         }
20210                                                     }
20211                                                   else
20212                                                     {
20213                                                       /* 33222222222211111111110000000000
20214                                                          10987654321098765432109876543210
20215                                                          xx101110xx1xxxxx011110xxxxxxxxxx
20216                                                          sqneg.  */
20217                                                       return 218;
20218                                                     }
20219                                                 }
20220                                             }
20221                                         }
20222                                     }
20223                                   else
20224                                     {
20225                                       if (((word >> 11) & 0x1) == 0)
20226                                         {
20227                                           if (((word >> 12) & 0x1) == 0)
20228                                             {
20229                                               if (((word >> 13) & 0x1) == 0)
20230                                                 {
20231                                                   if (((word >> 14) & 0x1) == 0)
20232                                                     {
20233                                                       /* 33222222222211111111110000000000
20234                                                          10987654321098765432109876543210
20235                                                          xx101110xx1xxxxx000001xxxxxxxxxx
20236                                                          uhadd.  */
20237                                                       return 320;
20238                                                     }
20239                                                   else
20240                                                     {
20241                                                       /* 33222222222211111111110000000000
20242                                                          10987654321098765432109876543210
20243                                                          xx101110xx1xxxxx010001xxxxxxxxxx
20244                                                          ushl.  */
20245                                                       return 327;
20246                                                     }
20247                                                 }
20248                                               else
20249                                                 {
20250                                                   if (((word >> 14) & 0x1) == 0)
20251                                                     {
20252                                                       /* 33222222222211111111110000000000
20253                                                          10987654321098765432109876543210
20254                                                          xx101110xx1xxxxx001001xxxxxxxxxx
20255                                                          uhsub.  */
20256                                                       return 323;
20257                                                     }
20258                                                   else
20259                                                     {
20260                                                       /* 33222222222211111111110000000000
20261                                                          10987654321098765432109876543210
20262                                                          xx101110xx1xxxxx011001xxxxxxxxxx
20263                                                          umax.  */
20264                                                       return 331;
20265                                                     }
20266                                                 }
20267                                             }
20268                                           else
20269                                             {
20270                                               if (((word >> 13) & 0x1) == 0)
20271                                                 {
20272                                                   if (((word >> 14) & 0x1) == 0)
20273                                                     {
20274                                                       /* 33222222222211111111110000000000
20275                                                          10987654321098765432109876543210
20276                                                          xx101110xx1xxxxx000101xxxxxxxxxx
20277                                                          urhadd.  */
20278                                                       return 322;
20279                                                     }
20280                                                   else
20281                                                     {
20282                                                       /* 33222222222211111111110000000000
20283                                                          10987654321098765432109876543210
20284                                                          xx101110xx1xxxxx010101xxxxxxxxxx
20285                                                          urshl.  */
20286                                                       return 329;
20287                                                     }
20288                                                 }
20289                                               else
20290                                                 {
20291                                                   if (((word >> 14) & 0x1) == 0)
20292                                                     {
20293                                                       /* 33222222222211111111110000000000
20294                                                          10987654321098765432109876543210
20295                                                          xx101110xx1xxxxx001101xxxxxxxxxx
20296                                                          cmhi.  */
20297                                                       return 325;
20298                                                     }
20299                                                   else
20300                                                     {
20301                                                       /* 33222222222211111111110000000000
20302                                                          10987654321098765432109876543210
20303                                                          xx101110xx1xxxxx011101xxxxxxxxxx
20304                                                          uabd.  */
20305                                                       return 333;
20306                                                     }
20307                                                 }
20308                                             }
20309                                         }
20310                                       else
20311                                         {
20312                                           if (((word >> 12) & 0x1) == 0)
20313                                             {
20314                                               if (((word >> 13) & 0x1) == 0)
20315                                                 {
20316                                                   if (((word >> 14) & 0x1) == 0)
20317                                                     {
20318                                                       /* 33222222222211111111110000000000
20319                                                          10987654321098765432109876543210
20320                                                          xx101110xx1xxxxx000011xxxxxxxxxx
20321                                                          uqadd.  */
20322                                                       return 321;
20323                                                     }
20324                                                   else
20325                                                     {
20326                                                       /* 33222222222211111111110000000000
20327                                                          10987654321098765432109876543210
20328                                                          xx101110xx1xxxxx010011xxxxxxxxxx
20329                                                          uqshl.  */
20330                                                       return 328;
20331                                                     }
20332                                                 }
20333                                               else
20334                                                 {
20335                                                   if (((word >> 14) & 0x1) == 0)
20336                                                     {
20337                                                       /* 33222222222211111111110000000000
20338                                                          10987654321098765432109876543210
20339                                                          xx101110xx1xxxxx001011xxxxxxxxxx
20340                                                          uqsub.  */
20341                                                       return 324;
20342                                                     }
20343                                                   else
20344                                                     {
20345                                                       /* 33222222222211111111110000000000
20346                                                          10987654321098765432109876543210
20347                                                          xx101110xx1xxxxx011011xxxxxxxxxx
20348                                                          umin.  */
20349                                                       return 332;
20350                                                     }
20351                                                 }
20352                                             }
20353                                           else
20354                                             {
20355                                               if (((word >> 13) & 0x1) == 0)
20356                                                 {
20357                                                   if (((word >> 14) & 0x1) == 0)
20358                                                     {
20359                                                       if (((word >> 22) & 0x1) == 0)
20360                                                         {
20361                                                           if (((word >> 23) & 0x1) == 0)
20362                                                             {
20363                                                               /* 33222222222211111111110000000000
20364                                                                  10987654321098765432109876543210
20365                                                                  xx101110001xxxxx000111xxxxxxxxxx
20366                                                                  eor.  */
20367                                                               return 356;
20368                                                             }
20369                                                           else
20370                                                             {
20371                                                               /* 33222222222211111111110000000000
20372                                                                  10987654321098765432109876543210
20373                                                                  xx101110101xxxxx000111xxxxxxxxxx
20374                                                                  bit.  */
20375                                                               return 368;
20376                                                             }
20377                                                         }
20378                                                       else
20379                                                         {
20380                                                           if (((word >> 23) & 0x1) == 0)
20381                                                             {
20382                                                               /* 33222222222211111111110000000000
20383                                                                  10987654321098765432109876543210
20384                                                                  xx101110011xxxxx000111xxxxxxxxxx
20385                                                                  bsl.  */
20386                                                               return 357;
20387                                                             }
20388                                                           else
20389                                                             {
20390                                                               /* 33222222222211111111110000000000
20391                                                                  10987654321098765432109876543210
20392                                                                  xx101110111xxxxx000111xxxxxxxxxx
20393                                                                  bif.  */
20394                                                               return 369;
20395                                                             }
20396                                                         }
20397                                                     }
20398                                                   else
20399                                                     {
20400                                                       /* 33222222222211111111110000000000
20401                                                          10987654321098765432109876543210
20402                                                          xx101110xx1xxxxx010111xxxxxxxxxx
20403                                                          uqrshl.  */
20404                                                       return 330;
20405                                                     }
20406                                                 }
20407                                               else
20408                                                 {
20409                                                   if (((word >> 14) & 0x1) == 0)
20410                                                     {
20411                                                       /* 33222222222211111111110000000000
20412                                                          10987654321098765432109876543210
20413                                                          xx101110xx1xxxxx001111xxxxxxxxxx
20414                                                          cmhs.  */
20415                                                       return 326;
20416                                                     }
20417                                                   else
20418                                                     {
20419                                                       /* 33222222222211111111110000000000
20420                                                          10987654321098765432109876543210
20421                                                          xx101110xx1xxxxx011111xxxxxxxxxx
20422                                                          uaba.  */
20423                                                       return 334;
20424                                                     }
20425                                                 }
20426                                             }
20427                                         }
20428                                     }
20429                                 }
20430                             }
20431                           else
20432                             {
20433                               if (((word >> 10) & 0x1) == 0)
20434                                 {
20435                                   if (((word >> 11) & 0x1) == 0)
20436                                     {
20437                                       if (((word >> 12) & 0x1) == 0)
20438                                         {
20439                                           if (((word >> 13) & 0x1) == 0)
20440                                             {
20441                                               if (((word >> 14) & 0x1) == 0)
20442                                                 {
20443                                                   if (((word >> 29) & 0x1) == 0)
20444                                                     {
20445                                                       if (((word >> 30) & 0x1) == 0)
20446                                                         {
20447                                                           /* 33222222222211111111110000000000
20448                                                              10987654321098765432109876543210
20449                                                              x0001110xx1xxxxx100000xxxxxxxxxx
20450                                                              smlal.  */
20451                                                           return 60;
20452                                                         }
20453                                                       else
20454                                                         {
20455                                                           if (((word >> 31) & 0x1) == 0)
20456                                                             {
20457                                                               /* 33222222222211111111110000000000
20458                                                                  10987654321098765432109876543210
20459                                                                  01001110xx1xxxxx100000xxxxxxxxxx
20460                                                                  smlal2.  */
20461                                                               return 61;
20462                                                             }
20463                                                           else
20464                                                             {
20465                                                               /* 33222222222211111111110000000000
20466                                                                  10987654321098765432109876543210
20467                                                                  11001110xx1xxxxx100000xxxxxxxxxx
20468                                                                  sha512h.  */
20469                                                               return 2419;
20470                                                             }
20471                                                         }
20472                                                     }
20473                                                   else
20474                                                     {
20475                                                       if (((word >> 30) & 0x1) == 0)
20476                                                         {
20477                                                           /* 33222222222211111111110000000000
20478                                                              10987654321098765432109876543210
20479                                                              x0101110xx1xxxxx100000xxxxxxxxxx
20480                                                              umlal.  */
20481                                                           return 92;
20482                                                         }
20483                                                       else
20484                                                         {
20485                                                           /* 33222222222211111111110000000000
20486                                                              10987654321098765432109876543210
20487                                                              x1101110xx1xxxxx100000xxxxxxxxxx
20488                                                              umlal2.  */
20489                                                           return 93;
20490                                                         }
20491                                                     }
20492                                                 }
20493                                               else
20494                                                 {
20495                                                   if (((word >> 29) & 0x1) == 0)
20496                                                     {
20497                                                       if (((word >> 30) & 0x1) == 0)
20498                                                         {
20499                                                           /* 33222222222211111111110000000000
20500                                                              10987654321098765432109876543210
20501                                                              x0001110xx1xxxxx110000xxxxxxxxxx
20502                                                              smull.  */
20503                                                           return 68;
20504                                                         }
20505                                                       else
20506                                                         {
20507                                                           if (((word >> 31) & 0x1) == 0)
20508                                                             {
20509                                                               /* 33222222222211111111110000000000
20510                                                                  10987654321098765432109876543210
20511                                                                  01001110xx1xxxxx110000xxxxxxxxxx
20512                                                                  smull2.  */
20513                                                               return 69;
20514                                                             }
20515                                                           else
20516                                                             {
20517                                                               /* 33222222222211111111110000000000
20518                                                                  10987654321098765432109876543210
20519                                                                  11001110xx1xxxxx110000xxxxxxxxxx
20520                                                                  sm3partw1.  */
20521                                                               return 2432;
20522                                                             }
20523                                                         }
20524                                                     }
20525                                                   else
20526                                                     {
20527                                                       if (((word >> 30) & 0x1) == 0)
20528                                                         {
20529                                                           /* 33222222222211111111110000000000
20530                                                              10987654321098765432109876543210
20531                                                              x0101110xx1xxxxx110000xxxxxxxxxx
20532                                                              umull.  */
20533                                                           return 96;
20534                                                         }
20535                                                       else
20536                                                         {
20537                                                           /* 33222222222211111111110000000000
20538                                                              10987654321098765432109876543210
20539                                                              x1101110xx1xxxxx110000xxxxxxxxxx
20540                                                              umull2.  */
20541                                                           return 97;
20542                                                         }
20543                                                     }
20544                                                 }
20545                                             }
20546                                           else
20547                                             {
20548                                               if (((word >> 14) & 0x1) == 0)
20549                                                 {
20550                                                   if (((word >> 29) & 0x1) == 0)
20551                                                     {
20552                                                       if (((word >> 30) & 0x1) == 0)
20553                                                         {
20554                                                           /* 33222222222211111111110000000000
20555                                                              10987654321098765432109876543210
20556                                                              x0001110xx1xxxxx101000xxxxxxxxxx
20557                                                              smlsl.  */
20558                                                           return 64;
20559                                                         }
20560                                                       else
20561                                                         {
20562                                                           /* 33222222222211111111110000000000
20563                                                              10987654321098765432109876543210
20564                                                              x1001110xx1xxxxx101000xxxxxxxxxx
20565                                                              smlsl2.  */
20566                                                           return 65;
20567                                                         }
20568                                                     }
20569                                                   else
20570                                                     {
20571                                                       if (((word >> 30) & 0x1) == 0)
20572                                                         {
20573                                                           /* 33222222222211111111110000000000
20574                                                              10987654321098765432109876543210
20575                                                              x0101110xx1xxxxx101000xxxxxxxxxx
20576                                                              umlsl.  */
20577                                                           return 94;
20578                                                         }
20579                                                       else
20580                                                         {
20581                                                           /* 33222222222211111111110000000000
20582                                                              10987654321098765432109876543210
20583                                                              x1101110xx1xxxxx101000xxxxxxxxxx
20584                                                              umlsl2.  */
20585                                                           return 95;
20586                                                         }
20587                                                     }
20588                                                 }
20589                                               else
20590                                                 {
20591                                                   if (((word >> 22) & 0x1) == 0)
20592                                                     {
20593                                                       if (((word >> 30) & 0x1) == 0)
20594                                                         {
20595                                                           /* 33222222222211111111110000000000
20596                                                              10987654321098765432109876543210
20597                                                              x0x01110x01xxxxx111000xxxxxxxxxx
20598                                                              pmull.  */
20599                                                           return 72;
20600                                                         }
20601                                                       else
20602                                                         {
20603                                                           /* 33222222222211111111110000000000
20604                                                              10987654321098765432109876543210
20605                                                              x1x01110x01xxxxx111000xxxxxxxxxx
20606                                                              pmull2.  */
20607                                                           return 74;
20608                                                         }
20609                                                     }
20610                                                   else
20611                                                     {
20612                                                       if (((word >> 30) & 0x1) == 0)
20613                                                         {
20614                                                           /* 33222222222211111111110000000000
20615                                                              10987654321098765432109876543210
20616                                                              x0x01110x11xxxxx111000xxxxxxxxxx
20617                                                              pmull.  */
20618                                                           return 73;
20619                                                         }
20620                                                       else
20621                                                         {
20622                                                           /* 33222222222211111111110000000000
20623                                                              10987654321098765432109876543210
20624                                                              x1x01110x11xxxxx111000xxxxxxxxxx
20625                                                              pmull2.  */
20626                                                           return 75;
20627                                                         }
20628                                                     }
20629                                                 }
20630                                             }
20631                                         }
20632                                       else
20633                                         {
20634                                           if (((word >> 13) & 0x1) == 0)
20635                                             {
20636                                               if (((word >> 14) & 0x1) == 0)
20637                                                 {
20638                                                   if (((word >> 30) & 0x1) == 0)
20639                                                     {
20640                                                       /* 33222222222211111111110000000000
20641                                                          10987654321098765432109876543210
20642                                                          x0x01110xx1xxxxx100100xxxxxxxxxx
20643                                                          sqdmlal.  */
20644                                                       return 62;
20645                                                     }
20646                                                   else
20647                                                     {
20648                                                       /* 33222222222211111111110000000000
20649                                                          10987654321098765432109876543210
20650                                                          x1x01110xx1xxxxx100100xxxxxxxxxx
20651                                                          sqdmlal2.  */
20652                                                       return 63;
20653                                                     }
20654                                                 }
20655                                               else
20656                                                 {
20657                                                   if (((word >> 30) & 0x1) == 0)
20658                                                     {
20659                                                       /* 33222222222211111111110000000000
20660                                                          10987654321098765432109876543210
20661                                                          x0x01110xx1xxxxx110100xxxxxxxxxx
20662                                                          sqdmull.  */
20663                                                       return 70;
20664                                                     }
20665                                                   else
20666                                                     {
20667                                                       /* 33222222222211111111110000000000
20668                                                          10987654321098765432109876543210
20669                                                          x1x01110xx1xxxxx110100xxxxxxxxxx
20670                                                          sqdmull2.  */
20671                                                       return 71;
20672                                                     }
20673                                                 }
20674                                             }
20675                                           else
20676                                             {
20677                                               if (((word >> 30) & 0x1) == 0)
20678                                                 {
20679                                                   /* 33222222222211111111110000000000
20680                                                      10987654321098765432109876543210
20681                                                      x0x01110xx1xxxxx1x1100xxxxxxxxxx
20682                                                      sqdmlsl.  */
20683                                                   return 66;
20684                                                 }
20685                                               else
20686                                                 {
20687                                                   /* 33222222222211111111110000000000
20688                                                      10987654321098765432109876543210
20689                                                      x1x01110xx1xxxxx1x1100xxxxxxxxxx
20690                                                      sqdmlsl2.  */
20691                                                   return 67;
20692                                                 }
20693                                             }
20694                                         }
20695                                     }
20696                                   else
20697                                     {
20698                                       if (((word >> 12) & 0x1) == 0)
20699                                         {
20700                                           if (((word >> 13) & 0x1) == 0)
20701                                             {
20702                                               if (((word >> 14) & 0x1) == 0)
20703                                                 {
20704                                                   if (((word >> 29) & 0x1) == 0)
20705                                                     {
20706                                                       if (((word >> 31) & 0x1) == 0)
20707                                                         {
20708                                                           if (((word >> 16) & 0x1) == 0)
20709                                                             {
20710                                                               /* 33222222222211111111110000000000
20711                                                                  10987654321098765432109876543210
20712                                                                  0x001110xx1xxxx0100010xxxxxxxxxx
20713                                                                  cmgt.  */
20714                                                               return 170;
20715                                                             }
20716                                                           else
20717                                                             {
20718                                                               if (((word >> 19) & 0x1) == 0)
20719                                                                 {
20720                                                                   if (((word >> 23) & 0x1) == 0)
20721                                                                     {
20722                                                                       /* 33222222222211111111110000000000
20723                                                                          10987654321098765432109876543210
20724                                                                          0x0011100x1x0xx1100010xxxxxxxxxx
20725                                                                          frintn.  */
20726                                                                       return 182;
20727                                                                     }
20728                                                                   else
20729                                                                     {
20730                                                                       /* 33222222222211111111110000000000
20731                                                                          10987654321098765432109876543210
20732                                                                          0x0011101x1x0xx1100010xxxxxxxxxx
20733                                                                          frintp.  */
20734                                                                       return 202;
20735                                                                     }
20736                                                                 }
20737                                                               else
20738                                                                 {
20739                                                                   if (((word >> 23) & 0x1) == 0)
20740                                                                     {
20741                                                                       /* 33222222222211111111110000000000
20742                                                                          10987654321098765432109876543210
20743                                                                          0x0011100x1x1xx1100010xxxxxxxxxx
20744                                                                          frintn.  */
20745                                                                       return 183;
20746                                                                     }
20747                                                                   else
20748                                                                     {
20749                                                                       /* 33222222222211111111110000000000
20750                                                                          10987654321098765432109876543210
20751                                                                          0x0011101x1x1xx1100010xxxxxxxxxx
20752                                                                          frintp.  */
20753                                                                       return 203;
20754                                                                     }
20755                                                                 }
20756                                                             }
20757                                                         }
20758                                                       else
20759                                                         {
20760                                                           /* 33222222222211111111110000000000
20761                                                              10987654321098765432109876543210
20762                                                              1x001110xx1xxxxx100010xxxxxxxxxx
20763                                                              sha512su1.  */
20764                                                           return 2422;
20765                                                         }
20766                                                     }
20767                                                   else
20768                                                     {
20769                                                       if (((word >> 16) & 0x1) == 0)
20770                                                         {
20771                                                           /* 33222222222211111111110000000000
20772                                                              10987654321098765432109876543210
20773                                                              xx101110xx1xxxx0100010xxxxxxxxxx
20774                                                              cmge.  */
20775                                                           return 219;
20776                                                         }
20777                                                       else
20778                                                         {
20779                                                           if (((word >> 19) & 0x1) == 0)
20780                                                             {
20781                                                               /* 33222222222211111111110000000000
20782                                                                  10987654321098765432109876543210
20783                                                                  xx101110xx1x0xx1100010xxxxxxxxxx
20784                                                                  frinta.  */
20785                                                               return 230;
20786                                                             }
20787                                                           else
20788                                                             {
20789                                                               /* 33222222222211111111110000000000
20790                                                                  10987654321098765432109876543210
20791                                                                  xx101110xx1x1xx1100010xxxxxxxxxx
20792                                                                  frinta.  */
20793                                                               return 231;
20794                                                             }
20795                                                         }
20796                                                     }
20797                                                 }
20798                                               else
20799                                                 {
20800                                                   if (((word >> 23) & 0x1) == 0)
20801                                                     {
20802                                                       if (((word >> 29) & 0x1) == 0)
20803                                                         {
20804                                                           if (((word >> 31) & 0x1) == 0)
20805                                                             {
20806                                                               if (((word >> 16) & 0x1) == 0)
20807                                                                 {
20808                                                                   /* 33222222222211111111110000000000
20809                                                                      10987654321098765432109876543210
20810                                                                      0x0011100x1xxxx0110010xxxxxxxxxx
20811                                                                      fmaxnmv.  */
20812                                                                   return 37;
20813                                                                 }
20814                                                               else
20815                                                                 {
20816                                                                   if (((word >> 19) & 0x1) == 0)
20817                                                                     {
20818                                                                       /* 33222222222211111111110000000000
20819                                                                          10987654321098765432109876543210
20820                                                                          0x0011100x1x0xx1110010xxxxxxxxxx
20821                                                                          fcvtas.  */
20822                                                                       return 190;
20823                                                                     }
20824                                                                   else
20825                                                                     {
20826                                                                       /* 33222222222211111111110000000000
20827                                                                          10987654321098765432109876543210
20828                                                                          0x0011100x1x1xx1110010xxxxxxxxxx
20829                                                                          fcvtas.  */
20830                                                                       return 191;
20831                                                                     }
20832                                                                 }
20833                                                             }
20834                                                           else
20835                                                             {
20836                                                               /* 33222222222211111111110000000000
20837                                                                  10987654321098765432109876543210
20838                                                                  1x0011100x1xxxxx110010xxxxxxxxxx
20839                                                                  sm4ekey.  */
20840                                                               return 2435;
20841                                                             }
20842                                                         }
20843                                                       else
20844                                                         {
20845                                                           if (((word >> 16) & 0x1) == 0)
20846                                                             {
20847                                                               /* 33222222222211111111110000000000
20848                                                                  10987654321098765432109876543210
20849                                                                  xx1011100x1xxxx0110010xxxxxxxxxx
20850                                                                  fmaxnmv.  */
20851                                                               return 36;
20852                                                             }
20853                                                           else
20854                                                             {
20855                                                               if (((word >> 19) & 0x1) == 0)
20856                                                                 {
20857                                                                   /* 33222222222211111111110000000000
20858                                                                      10987654321098765432109876543210
20859                                                                      xx1011100x1x0xx1110010xxxxxxxxxx
20860                                                                      fcvtau.  */
20861                                                                   return 238;
20862                                                                 }
20863                                                               else
20864                                                                 {
20865                                                                   /* 33222222222211111111110000000000
20866                                                                      10987654321098765432109876543210
20867                                                                      xx1011100x1x1xx1110010xxxxxxxxxx
20868                                                                      fcvtau.  */
20869                                                                   return 239;
20870                                                                 }
20871                                                             }
20872                                                         }
20873                                                     }
20874                                                   else
20875                                                     {
20876                                                       if (((word >> 16) & 0x1) == 0)
20877                                                         {
20878                                                           if (((word >> 19) & 0x1) == 0)
20879                                                             {
20880                                                               if (((word >> 20) & 0x1) == 0)
20881                                                                 {
20882                                                                   if (((word >> 29) & 0x1) == 0)
20883                                                                     {
20884                                                                       /* 33222222222211111111110000000000
20885                                                                          10987654321098765432109876543210
20886                                                                          xx0011101x100xx0110010xxxxxxxxxx
20887                                                                          fcmgt.  */
20888                                                                       return 194;
20889                                                                     }
20890                                                                   else
20891                                                                     {
20892                                                                       /* 33222222222211111111110000000000
20893                                                                          10987654321098765432109876543210
20894                                                                          xx1011101x100xx0110010xxxxxxxxxx
20895                                                                          fcmge.  */
20896                                                                       return 245;
20897                                                                     }
20898                                                                 }
20899                                                               else
20900                                                                 {
20901                                                                   if (((word >> 29) & 0x1) == 0)
20902                                                                     {
20903                                                                       /* 33222222222211111111110000000000
20904                                                                          10987654321098765432109876543210
20905                                                                          xx0011101x110xx0110010xxxxxxxxxx
20906                                                                          fminnmv.  */
20907                                                                       return 41;
20908                                                                     }
20909                                                                   else
20910                                                                     {
20911                                                                       /* 33222222222211111111110000000000
20912                                                                          10987654321098765432109876543210
20913                                                                          xx1011101x110xx0110010xxxxxxxxxx
20914                                                                          fminnmv.  */
20915                                                                       return 40;
20916                                                                     }
20917                                                                 }
20918                                                             }
20919                                                           else
20920                                                             {
20921                                                               if (((word >> 29) & 0x1) == 0)
20922                                                                 {
20923                                                                   /* 33222222222211111111110000000000
20924                                                                      10987654321098765432109876543210
20925                                                                      xx0011101x1x1xx0110010xxxxxxxxxx
20926                                                                      fcmgt.  */
20927                                                                   return 195;
20928                                                                 }
20929                                                               else
20930                                                                 {
20931                                                                   /* 33222222222211111111110000000000
20932                                                                      10987654321098765432109876543210
20933                                                                      xx1011101x1x1xx0110010xxxxxxxxxx
20934                                                                      fcmge.  */
20935                                                                   return 246;
20936                                                                 }
20937                                                             }
20938                                                         }
20939                                                       else
20940                                                         {
20941                                                           if (((word >> 29) & 0x1) == 0)
20942                                                             {
20943                                                               /* 33222222222211111111110000000000
20944                                                                  10987654321098765432109876543210
20945                                                                  xx0011101x1xxxx1110010xxxxxxxxxx
20946                                                                  urecpe.  */
20947                                                               return 210;
20948                                                             }
20949                                                           else
20950                                                             {
20951                                                               /* 33222222222211111111110000000000
20952                                                                  10987654321098765432109876543210
20953                                                                  xx1011101x1xxxx1110010xxxxxxxxxx
20954                                                                  ursqrte.  */
20955                                                               return 257;
20956                                                             }
20957                                                         }
20958                                                     }
20959                                                 }
20960                                             }
20961                                           else
20962                                             {
20963                                               if (((word >> 14) & 0x1) == 0)
20964                                                 {
20965                                                   if (((word >> 16) & 0x1) == 0)
20966                                                     {
20967                                                       if (((word >> 20) & 0x1) == 0)
20968                                                         {
20969                                                           /* 33222222222211111111110000000000
20970                                                              10987654321098765432109876543210
20971                                                              xxx01110xx10xxx0101010xxxxxxxxxx
20972                                                              cmlt.  */
20973                                                           return 172;
20974                                                         }
20975                                                       else
20976                                                         {
20977                                                           if (((word >> 29) & 0x1) == 0)
20978                                                             {
20979                                                               /* 33222222222211111111110000000000
20980                                                                  10987654321098765432109876543210
20981                                                                  xx001110xx11xxx0101010xxxxxxxxxx
20982                                                                  smaxv.  */
20983                                                               return 30;
20984                                                             }
20985                                                           else
20986                                                             {
20987                                                               /* 33222222222211111111110000000000
20988                                                                  10987654321098765432109876543210
20989                                                                  xx101110xx11xxx0101010xxxxxxxxxx
20990                                                                  umaxv.  */
20991                                                               return 34;
20992                                                             }
20993                                                         }
20994                                                     }
20995                                                   else
20996                                                     {
20997                                                       if (((word >> 19) & 0x1) == 0)
20998                                                         {
20999                                                           if (((word >> 20) & 0x1) == 0)
21000                                                             {
21001                                                               if (((word >> 23) & 0x1) == 0)
21002                                                                 {
21003                                                                   if (((word >> 29) & 0x1) == 0)
21004                                                                     {
21005                                                                       /* 33222222222211111111110000000000
21006                                                                          10987654321098765432109876543210
21007                                                                          xx0011100x100xx1101010xxxxxxxxxx
21008                                                                          fcvtns.  */
21009                                                                       return 186;
21010                                                                     }
21011                                                                   else
21012                                                                     {
21013                                                                       /* 33222222222211111111110000000000
21014                                                                          10987654321098765432109876543210
21015                                                                          xx1011100x100xx1101010xxxxxxxxxx
21016                                                                          fcvtnu.  */
21017                                                                       return 234;
21018                                                                     }
21019                                                                 }
21020                                                               else
21021                                                                 {
21022                                                                   if (((word >> 29) & 0x1) == 0)
21023                                                                     {
21024                                                                       /* 33222222222211111111110000000000
21025                                                                          10987654321098765432109876543210
21026                                                                          xx0011101x100xx1101010xxxxxxxxxx
21027                                                                          fcvtps.  */
21028                                                                       return 206;
21029                                                                     }
21030                                                                   else
21031                                                                     {
21032                                                                       /* 33222222222211111111110000000000
21033                                                                          10987654321098765432109876543210
21034                                                                          xx1011101x100xx1101010xxxxxxxxxx
21035                                                                          fcvtpu.  */
21036                                                                       return 253;
21037                                                                     }
21038                                                                 }
21039                                                             }
21040                                                           else
21041                                                             {
21042                                                               if (((word >> 29) & 0x1) == 0)
21043                                                                 {
21044                                                                   /* 33222222222211111111110000000000
21045                                                                      10987654321098765432109876543210
21046                                                                      xx001110xx110xx1101010xxxxxxxxxx
21047                                                                      sminv.  */
21048                                                                   return 31;
21049                                                                 }
21050                                                               else
21051                                                                 {
21052                                                                   /* 33222222222211111111110000000000
21053                                                                      10987654321098765432109876543210
21054                                                                      xx101110xx110xx1101010xxxxxxxxxx
21055                                                                      uminv.  */
21056                                                                   return 35;
21057                                                                 }
21058                                                             }
21059                                                         }
21060                                                       else
21061                                                         {
21062                                                           if (((word >> 23) & 0x1) == 0)
21063                                                             {
21064                                                               if (((word >> 29) & 0x1) == 0)
21065                                                                 {
21066                                                                   /* 33222222222211111111110000000000
21067                                                                      10987654321098765432109876543210
21068                                                                      xx0011100x1x1xx1101010xxxxxxxxxx
21069                                                                      fcvtns.  */
21070                                                                   return 187;
21071                                                                 }
21072                                                               else
21073                                                                 {
21074                                                                   /* 33222222222211111111110000000000
21075                                                                      10987654321098765432109876543210
21076                                                                      xx1011100x1x1xx1101010xxxxxxxxxx
21077                                                                      fcvtnu.  */
21078                                                                   return 235;
21079                                                                 }
21080                                                             }
21081                                                           else
21082                                                             {
21083                                                               if (((word >> 29) & 0x1) == 0)
21084                                                                 {
21085                                                                   /* 33222222222211111111110000000000
21086                                                                      10987654321098765432109876543210
21087                                                                      xx0011101x1x1xx1101010xxxxxxxxxx
21088                                                                      fcvtps.  */
21089                                                                   return 207;
21090                                                                 }
21091                                                               else
21092                                                                 {
21093                                                                   /* 33222222222211111111110000000000
21094                                                                      10987654321098765432109876543210
21095                                                                      xx1011101x1x1xx1101010xxxxxxxxxx
21096                                                                      fcvtpu.  */
21097                                                                   return 254;
21098                                                                 }
21099                                                             }
21100                                                         }
21101                                                     }
21102                                                 }
21103                                               else
21104                                                 {
21105                                                   if (((word >> 16) & 0x1) == 0)
21106                                                     {
21107                                                       if (((word >> 19) & 0x1) == 0)
21108                                                         {
21109                                                           /* 33222222222211111111110000000000
21110                                                              10987654321098765432109876543210
21111                                                              xxx01110xx1x0xx0111010xxxxxxxxxx
21112                                                              fcmlt.  */
21113                                                           return 198;
21114                                                         }
21115                                                       else
21116                                                         {
21117                                                           /* 33222222222211111111110000000000
21118                                                              10987654321098765432109876543210
21119                                                              xxx01110xx1x1xx0111010xxxxxxxxxx
21120                                                              fcmlt.  */
21121                                                           return 199;
21122                                                         }
21123                                                     }
21124                                                   else
21125                                                     {
21126                                                       if (((word >> 29) & 0x1) == 0)
21127                                                         {
21128                                                           /* 33222222222211111111110000000000
21129                                                              10987654321098765432109876543210
21130                                                              xx001110xx1xxxx1111010xxxxxxxxxx
21131                                                              frint32z.  */
21132                                                           return 158;
21133                                                         }
21134                                                       else
21135                                                         {
21136                                                           /* 33222222222211111111110000000000
21137                                                              10987654321098765432109876543210
21138                                                              xx101110xx1xxxx1111010xxxxxxxxxx
21139                                                              frint32x.  */
21140                                                           return 159;
21141                                                         }
21142                                                     }
21143                                                 }
21144                                             }
21145                                         }
21146                                       else
21147                                         {
21148                                           if (((word >> 13) & 0x1) == 0)
21149                                             {
21150                                               if (((word >> 14) & 0x1) == 0)
21151                                                 {
21152                                                   if (((word >> 16) & 0x1) == 0)
21153                                                     {
21154                                                       if (((word >> 29) & 0x1) == 0)
21155                                                         {
21156                                                           /* 33222222222211111111110000000000
21157                                                              10987654321098765432109876543210
21158                                                              xx001110xx1xxxx0100110xxxxxxxxxx
21159                                                              cmeq.  */
21160                                                           return 171;
21161                                                         }
21162                                                       else
21163                                                         {
21164                                                           /* 33222222222211111111110000000000
21165                                                              10987654321098765432109876543210
21166                                                              xx101110xx1xxxx0100110xxxxxxxxxx
21167                                                              cmle.  */
21168                                                           return 220;
21169                                                         }
21170                                                     }
21171                                                   else
21172                                                     {
21173                                                       if (((word >> 19) & 0x1) == 0)
21174                                                         {
21175                                                           if (((word >> 23) & 0x1) == 0)
21176                                                             {
21177                                                               if (((word >> 29) & 0x1) == 0)
21178                                                                 {
21179                                                                   /* 33222222222211111111110000000000
21180                                                                      10987654321098765432109876543210
21181                                                                      xx0011100x1x0xx1100110xxxxxxxxxx
21182                                                                      frintm.  */
21183                                                                   return 184;
21184                                                                 }
21185                                                               else
21186                                                                 {
21187                                                                   /* 33222222222211111111110000000000
21188                                                                      10987654321098765432109876543210
21189                                                                      xx1011100x1x0xx1100110xxxxxxxxxx
21190                                                                      frintx.  */
21191                                                                   return 232;
21192                                                                 }
21193                                                             }
21194                                                           else
21195                                                             {
21196                                                               if (((word >> 29) & 0x1) == 0)
21197                                                                 {
21198                                                                   /* 33222222222211111111110000000000
21199                                                                      10987654321098765432109876543210
21200                                                                      xx0011101x1x0xx1100110xxxxxxxxxx
21201                                                                      frintz.  */
21202                                                                   return 204;
21203                                                                 }
21204                                                               else
21205                                                                 {
21206                                                                   /* 33222222222211111111110000000000
21207                                                                      10987654321098765432109876543210
21208                                                                      xx1011101x1x0xx1100110xxxxxxxxxx
21209                                                                      frinti.  */
21210                                                                   return 251;
21211                                                                 }
21212                                                             }
21213                                                         }
21214                                                       else
21215                                                         {
21216                                                           if (((word >> 23) & 0x1) == 0)
21217                                                             {
21218                                                               if (((word >> 29) & 0x1) == 0)
21219                                                                 {
21220                                                                   /* 33222222222211111111110000000000
21221                                                                      10987654321098765432109876543210
21222                                                                      xx0011100x1x1xx1100110xxxxxxxxxx
21223                                                                      frintm.  */
21224                                                                   return 185;
21225                                                                 }
21226                                                               else
21227                                                                 {
21228                                                                   /* 33222222222211111111110000000000
21229                                                                      10987654321098765432109876543210
21230                                                                      xx1011100x1x1xx1100110xxxxxxxxxx
21231                                                                      frintx.  */
21232                                                                   return 233;
21233                                                                 }
21234                                                             }
21235                                                           else
21236                                                             {
21237                                                               if (((word >> 29) & 0x1) == 0)
21238                                                                 {
21239                                                                   /* 33222222222211111111110000000000
21240                                                                      10987654321098765432109876543210
21241                                                                      xx0011101x1x1xx1100110xxxxxxxxxx
21242                                                                      frintz.  */
21243                                                                   return 205;
21244                                                                 }
21245                                                               else
21246                                                                 {
21247                                                                   /* 33222222222211111111110000000000
21248                                                                      10987654321098765432109876543210
21249                                                                      xx1011101x1x1xx1100110xxxxxxxxxx
21250                                                                      frinti.  */
21251                                                                   return 252;
21252                                                                 }
21253                                                             }
21254                                                         }
21255                                                     }
21256                                                 }
21257                                               else
21258                                                 {
21259                                                   if (((word >> 16) & 0x1) == 0)
21260                                                     {
21261                                                       if (((word >> 19) & 0x1) == 0)
21262                                                         {
21263                                                           if (((word >> 29) & 0x1) == 0)
21264                                                             {
21265                                                               /* 33222222222211111111110000000000
21266                                                                  10987654321098765432109876543210
21267                                                                  xx001110xx1x0xx0110110xxxxxxxxxx
21268                                                                  fcmeq.  */
21269                                                               return 196;
21270                                                             }
21271                                                           else
21272                                                             {
21273                                                               /* 33222222222211111111110000000000
21274                                                                  10987654321098765432109876543210
21275                                                                  xx101110xx1x0xx0110110xxxxxxxxxx
21276                                                                  fcmle.  */
21277                                                               return 247;
21278                                                             }
21279                                                         }
21280                                                       else
21281                                                         {
21282                                                           if (((word >> 29) & 0x1) == 0)
21283                                                             {
21284                                                               /* 33222222222211111111110000000000
21285                                                                  10987654321098765432109876543210
21286                                                                  xx001110xx1x1xx0110110xxxxxxxxxx
21287                                                                  fcmeq.  */
21288                                                               return 197;
21289                                                             }
21290                                                           else
21291                                                             {
21292                                                               /* 33222222222211111111110000000000
21293                                                                  10987654321098765432109876543210
21294                                                                  xx101110xx1x1xx0110110xxxxxxxxxx
21295                                                                  fcmle.  */
21296                                                               return 248;
21297                                                             }
21298                                                         }
21299                                                     }
21300                                                   else
21301                                                     {
21302                                                       if (((word >> 19) & 0x1) == 0)
21303                                                         {
21304                                                           if (((word >> 23) & 0x1) == 0)
21305                                                             {
21306                                                               if (((word >> 29) & 0x1) == 0)
21307                                                                 {
21308                                                                   /* 33222222222211111111110000000000
21309                                                                      10987654321098765432109876543210
21310                                                                      xx0011100x1x0xx1110110xxxxxxxxxx
21311                                                                      scvtf.  */
21312                                                                   return 192;
21313                                                                 }
21314                                                               else
21315                                                                 {
21316                                                                   /* 33222222222211111111110000000000
21317                                                                      10987654321098765432109876543210
21318                                                                      xx1011100x1x0xx1110110xxxxxxxxxx
21319                                                                      ucvtf.  */
21320                                                                   return 240;
21321                                                                 }
21322                                                             }
21323                                                           else
21324                                                             {
21325                                                               if (((word >> 29) & 0x1) == 0)
21326                                                                 {
21327                                                                   /* 33222222222211111111110000000000
21328                                                                      10987654321098765432109876543210
21329                                                                      xx0011101x1x0xx1110110xxxxxxxxxx
21330                                                                      frecpe.  */
21331                                                                   return 211;
21332                                                                 }
21333                                                               else
21334                                                                 {
21335                                                                   /* 33222222222211111111110000000000
21336                                                                      10987654321098765432109876543210
21337                                                                      xx1011101x1x0xx1110110xxxxxxxxxx
21338                                                                      frsqrte.  */
21339                                                                   return 258;
21340                                                                 }
21341                                                             }
21342                                                         }
21343                                                       else
21344                                                         {
21345                                                           if (((word >> 23) & 0x1) == 0)
21346                                                             {
21347                                                               if (((word >> 29) & 0x1) == 0)
21348                                                                 {
21349                                                                   /* 33222222222211111111110000000000
21350                                                                      10987654321098765432109876543210
21351                                                                      xx0011100x1x1xx1110110xxxxxxxxxx
21352                                                                      scvtf.  */
21353                                                                   return 193;
21354                                                                 }
21355                                                               else
21356                                                                 {
21357                                                                   /* 33222222222211111111110000000000
21358                                                                      10987654321098765432109876543210
21359                                                                      xx1011100x1x1xx1110110xxxxxxxxxx
21360                                                                      ucvtf.  */
21361                                                                   return 241;
21362                                                                 }
21363                                                             }
21364                                                           else
21365                                                             {
21366                                                               if (((word >> 29) & 0x1) == 0)
21367                                                                 {
21368                                                                   /* 33222222222211111111110000000000
21369                                                                      10987654321098765432109876543210
21370                                                                      xx0011101x1x1xx1110110xxxxxxxxxx
21371                                                                      frecpe.  */
21372                                                                   return 212;
21373                                                                 }
21374                                                               else
21375                                                                 {
21376                                                                   /* 33222222222211111111110000000000
21377                                                                      10987654321098765432109876543210
21378                                                                      xx1011101x1x1xx1110110xxxxxxxxxx
21379                                                                      frsqrte.  */
21380                                                                   return 259;
21381                                                                 }
21382                                                             }
21383                                                         }
21384                                                     }
21385                                                 }
21386                                             }
21387                                           else
21388                                             {
21389                                               if (((word >> 14) & 0x1) == 0)
21390                                                 {
21391                                                   if (((word >> 16) & 0x1) == 0)
21392                                                     {
21393                                                       if (((word >> 29) & 0x1) == 0)
21394                                                         {
21395                                                           /* 33222222222211111111110000000000
21396                                                              10987654321098765432109876543210
21397                                                              xx001110xx1xxxx0101110xxxxxxxxxx
21398                                                              abs.  */
21399                                                           return 173;
21400                                                         }
21401                                                       else
21402                                                         {
21403                                                           /* 33222222222211111111110000000000
21404                                                              10987654321098765432109876543210
21405                                                              xx101110xx1xxxx0101110xxxxxxxxxx
21406                                                              neg.  */
21407                                                           return 221;
21408                                                         }
21409                                                     }
21410                                                   else
21411                                                     {
21412                                                       if (((word >> 19) & 0x1) == 0)
21413                                                         {
21414                                                           if (((word >> 20) & 0x1) == 0)
21415                                                             {
21416                                                               if (((word >> 23) & 0x1) == 0)
21417                                                                 {
21418                                                                   if (((word >> 29) & 0x1) == 0)
21419                                                                     {
21420                                                                       /* 33222222222211111111110000000000
21421                                                                          10987654321098765432109876543210
21422                                                                          xx0011100x100xx1101110xxxxxxxxxx
21423                                                                          fcvtms.  */
21424                                                                       return 188;
21425                                                                     }
21426                                                                   else
21427                                                                     {
21428                                                                       /* 33222222222211111111110000000000
21429                                                                          10987654321098765432109876543210
21430                                                                          xx1011100x100xx1101110xxxxxxxxxx
21431                                                                          fcvtmu.  */
21432                                                                       return 236;
21433                                                                     }
21434                                                                 }
21435                                                               else
21436                                                                 {
21437                                                                   if (((word >> 29) & 0x1) == 0)
21438                                                                     {
21439                                                                       /* 33222222222211111111110000000000
21440                                                                          10987654321098765432109876543210
21441                                                                          xx0011101x100xx1101110xxxxxxxxxx
21442                                                                          fcvtzs.  */
21443                                                                       return 208;
21444                                                                     }
21445                                                                   else
21446                                                                     {
21447                                                                       /* 33222222222211111111110000000000
21448                                                                          10987654321098765432109876543210
21449                                                                          xx1011101x100xx1101110xxxxxxxxxx
21450                                                                          fcvtzu.  */
21451                                                                       return 255;
21452                                                                     }
21453                                                                 }
21454                                                             }
21455                                                           else
21456                                                             {
21457                                                               /* 33222222222211111111110000000000
21458                                                                  10987654321098765432109876543210
21459                                                                  xxx01110xx110xx1101110xxxxxxxxxx
21460                                                                  addv.  */
21461                                                               return 32;
21462                                                             }
21463                                                         }
21464                                                       else
21465                                                         {
21466                                                           if (((word >> 23) & 0x1) == 0)
21467                                                             {
21468                                                               if (((word >> 29) & 0x1) == 0)
21469                                                                 {
21470                                                                   /* 33222222222211111111110000000000
21471                                                                      10987654321098765432109876543210
21472                                                                      xx0011100x1x1xx1101110xxxxxxxxxx
21473                                                                      fcvtms.  */
21474                                                                   return 189;
21475                                                                 }
21476                                                               else
21477                                                                 {
21478                                                                   /* 33222222222211111111110000000000
21479                                                                      10987654321098765432109876543210
21480                                                                      xx1011100x1x1xx1101110xxxxxxxxxx
21481                                                                      fcvtmu.  */
21482                                                                   return 237;
21483                                                                 }
21484                                                             }
21485                                                           else
21486                                                             {
21487                                                               if (((word >> 29) & 0x1) == 0)
21488                                                                 {
21489                                                                   /* 33222222222211111111110000000000
21490                                                                      10987654321098765432109876543210
21491                                                                      xx0011101x1x1xx1101110xxxxxxxxxx
21492                                                                      fcvtzs.  */
21493                                                                   return 209;
21494                                                                 }
21495                                                               else
21496                                                                 {
21497                                                                   /* 33222222222211111111110000000000
21498                                                                      10987654321098765432109876543210
21499                                                                      xx1011101x1x1xx1101110xxxxxxxxxx
21500                                                                      fcvtzu.  */
21501                                                                   return 256;
21502                                                                 }
21503                                                             }
21504                                                         }
21505                                                     }
21506                                                 }
21507                                               else
21508                                                 {
21509                                                   if (((word >> 16) & 0x1) == 0)
21510                                                     {
21511                                                       if (((word >> 19) & 0x1) == 0)
21512                                                         {
21513                                                           if (((word >> 20) & 0x1) == 0)
21514                                                             {
21515                                                               if (((word >> 29) & 0x1) == 0)
21516                                                                 {
21517                                                                   /* 33222222222211111111110000000000
21518                                                                      10987654321098765432109876543210
21519                                                                      xx001110xx100xx0111110xxxxxxxxxx
21520                                                                      fabs.  */
21521                                                                   return 200;
21522                                                                 }
21523                                                               else
21524                                                                 {
21525                                                                   /* 33222222222211111111110000000000
21526                                                                      10987654321098765432109876543210
21527                                                                      xx101110xx100xx0111110xxxxxxxxxx
21528                                                                      fneg.  */
21529                                                                   return 249;
21530                                                                 }
21531                                                             }
21532                                                           else
21533                                                             {
21534                                                               if (((word >> 23) & 0x1) == 0)
21535                                                                 {
21536                                                                   if (((word >> 29) & 0x1) == 0)
21537                                                                     {
21538                                                                       /* 33222222222211111111110000000000
21539                                                                          10987654321098765432109876543210
21540                                                                          xx0011100x110xx0111110xxxxxxxxxx
21541                                                                          fmaxv.  */
21542                                                                       return 39;
21543                                                                     }
21544                                                                   else
21545                                                                     {
21546                                                                       /* 33222222222211111111110000000000
21547                                                                          10987654321098765432109876543210
21548                                                                          xx1011100x110xx0111110xxxxxxxxxx
21549                                                                          fmaxv.  */
21550                                                                       return 38;
21551                                                                     }
21552                                                                 }
21553                                                               else
21554                                                                 {
21555                                                                   if (((word >> 29) & 0x1) == 0)
21556                                                                     {
21557                                                                       /* 33222222222211111111110000000000
21558                                                                          10987654321098765432109876543210
21559                                                                          xx0011101x110xx0111110xxxxxxxxxx
21560                                                                          fminv.  */
21561                                                                       return 43;
21562                                                                     }
21563                                                                   else
21564                                                                     {
21565                                                                       /* 33222222222211111111110000000000
21566                                                                          10987654321098765432109876543210
21567                                                                          xx1011101x110xx0111110xxxxxxxxxx
21568                                                                          fminv.  */
21569                                                                       return 42;
21570                                                                     }
21571                                                                 }
21572                                                             }
21573                                                         }
21574                                                       else
21575                                                         {
21576                                                           if (((word >> 29) & 0x1) == 0)
21577                                                             {
21578                                                               /* 33222222222211111111110000000000
21579                                                                  10987654321098765432109876543210
21580                                                                  xx001110xx1x1xx0111110xxxxxxxxxx
21581                                                                  fabs.  */
21582                                                               return 201;
21583                                                             }
21584                                                           else
21585                                                             {
21586                                                               /* 33222222222211111111110000000000
21587                                                                  10987654321098765432109876543210
21588                                                                  xx101110xx1x1xx0111110xxxxxxxxxx
21589                                                                  fneg.  */
21590                                                               return 250;
21591                                                             }
21592                                                         }
21593                                                     }
21594                                                   else
21595                                                     {
21596                                                       if (((word >> 19) & 0x1) == 0)
21597                                                         {
21598                                                           if (((word >> 23) & 0x1) == 0)
21599                                                             {
21600                                                               if (((word >> 29) & 0x1) == 0)
21601                                                                 {
21602                                                                   /* 33222222222211111111110000000000
21603                                                                      10987654321098765432109876543210
21604                                                                      xx0011100x1x0xx1111110xxxxxxxxxx
21605                                                                      frint64z.  */
21606                                                                   return 160;
21607                                                                 }
21608                                                               else
21609                                                                 {
21610                                                                   /* 33222222222211111111110000000000
21611                                                                      10987654321098765432109876543210
21612                                                                      xx1011100x1x0xx1111110xxxxxxxxxx
21613                                                                      frint64x.  */
21614                                                                   return 161;
21615                                                                 }
21616                                                             }
21617                                                           else
21618                                                             {
21619                                                               /* 33222222222211111111110000000000
21620                                                                  10987654321098765432109876543210
21621                                                                  xxx011101x1x0xx1111110xxxxxxxxxx
21622                                                                  fsqrt.  */
21623                                                               return 260;
21624                                                             }
21625                                                         }
21626                                                       else
21627                                                         {
21628                                                           /* 33222222222211111111110000000000
21629                                                              10987654321098765432109876543210
21630                                                              xxx01110xx1x1xx1111110xxxxxxxxxx
21631                                                              fsqrt.  */
21632                                                           return 261;
21633                                                         }
21634                                                     }
21635                                                 }
21636                                             }
21637                                         }
21638                                     }
21639                                 }
21640                               else
21641                                 {
21642                                   if (((word >> 11) & 0x1) == 0)
21643                                     {
21644                                       if (((word >> 12) & 0x1) == 0)
21645                                         {
21646                                           if (((word >> 13) & 0x1) == 0)
21647                                             {
21648                                               if (((word >> 14) & 0x1) == 0)
21649                                                 {
21650                                                   if (((word >> 29) & 0x1) == 0)
21651                                                     {
21652                                                       if (((word >> 31) & 0x1) == 0)
21653                                                         {
21654                                                           /* 33222222222211111111110000000000
21655                                                              10987654321098765432109876543210
21656                                                              0x001110xx1xxxxx100001xxxxxxxxxx
21657                                                              add.  */
21658                                                           return 283;
21659                                                         }
21660                                                       else
21661                                                         {
21662                                                           /* 33222222222211111111110000000000
21663                                                              10987654321098765432109876543210
21664                                                              1x001110xx1xxxxx100001xxxxxxxxxx
21665                                                              sha512h2.  */
21666                                                           return 2420;
21667                                                         }
21668                                                     }
21669                                                   else
21670                                                     {
21671                                                       /* 33222222222211111111110000000000
21672                                                          10987654321098765432109876543210
21673                                                          xx101110xx1xxxxx100001xxxxxxxxxx
21674                                                          sub.  */
21675                                                       return 335;
21676                                                     }
21677                                                 }
21678                                               else
21679                                                 {
21680                                                   if (((word >> 23) & 0x1) == 0)
21681                                                     {
21682                                                       if (((word >> 29) & 0x1) == 0)
21683                                                         {
21684                                                           if (((word >> 31) & 0x1) == 0)
21685                                                             {
21686                                                               /* 33222222222211111111110000000000
21687                                                                  10987654321098765432109876543210
21688                                                                  0x0011100x1xxxxx110001xxxxxxxxxx
21689                                                                  fmaxnm.  */
21690                                                               return 291;
21691                                                             }
21692                                                           else
21693                                                             {
21694                                                               /* 33222222222211111111110000000000
21695                                                                  10987654321098765432109876543210
21696                                                                  1x0011100x1xxxxx110001xxxxxxxxxx
21697                                                                  sm3partw2.  */
21698                                                               return 2433;
21699                                                             }
21700                                                         }
21701                                                       else
21702                                                         {
21703                                                           /* 33222222222211111111110000000000
21704                                                              10987654321098765432109876543210
21705                                                              xx1011100x1xxxxx110001xxxxxxxxxx
21706                                                              fmaxnmp.  */
21707                                                           return 342;
21708                                                         }
21709                                                     }
21710                                                   else
21711                                                     {
21712                                                       if (((word >> 29) & 0x1) == 0)
21713                                                         {
21714                                                           /* 33222222222211111111110000000000
21715                                                              10987654321098765432109876543210
21716                                                              xx0011101x1xxxxx110001xxxxxxxxxx
21717                                                              fminnm.  */
21718                                                           return 307;
21719                                                         }
21720                                                       else
21721                                                         {
21722                                                           /* 33222222222211111111110000000000
21723                                                              10987654321098765432109876543210
21724                                                              xx1011101x1xxxxx110001xxxxxxxxxx
21725                                                              fminnmp.  */
21726                                                           return 358;
21727                                                         }
21728                                                     }
21729                                                 }
21730                                             }
21731                                           else
21732                                             {
21733                                               if (((word >> 14) & 0x1) == 0)
21734                                                 {
21735                                                   if (((word >> 29) & 0x1) == 0)
21736                                                     {
21737                                                       /* 33222222222211111111110000000000
21738                                                          10987654321098765432109876543210
21739                                                          xx001110xx1xxxxx101001xxxxxxxxxx
21740                                                          smaxp.  */
21741                                                       return 287;
21742                                                     }
21743                                                   else
21744                                                     {
21745                                                       /* 33222222222211111111110000000000
21746                                                          10987654321098765432109876543210
21747                                                          xx101110xx1xxxxx101001xxxxxxxxxx
21748                                                          umaxp.  */
21749                                                       return 339;
21750                                                     }
21751                                                 }
21752                                               else
21753                                                 {
21754                                                   if (((word >> 23) & 0x1) == 0)
21755                                                     {
21756                                                       if (((word >> 29) & 0x1) == 0)
21757                                                         {
21758                                                           /* 33222222222211111111110000000000
21759                                                              10987654321098765432109876543210
21760                                                              xx0011100x1xxxxx111001xxxxxxxxxx
21761                                                              fcmeq.  */
21762                                                           return 299;
21763                                                         }
21764                                                       else
21765                                                         {
21766                                                           /* 33222222222211111111110000000000
21767                                                              10987654321098765432109876543210
21768                                                              xx1011100x1xxxxx111001xxxxxxxxxx
21769                                                              fcmge.  */
21770                                                           return 348;
21771                                                         }
21772                                                     }
21773                                                   else
21774                                                     {
21775                                                       /* 33222222222211111111110000000000
21776                                                          10987654321098765432109876543210
21777                                                          xxx011101x1xxxxx111001xxxxxxxxxx
21778                                                          fcmgt.  */
21779                                                       return 362;
21780                                                     }
21781                                                 }
21782                                             }
21783                                         }
21784                                       else
21785                                         {
21786                                           if (((word >> 13) & 0x1) == 0)
21787                                             {
21788                                               if (((word >> 14) & 0x1) == 0)
21789                                                 {
21790                                                   if (((word >> 29) & 0x1) == 0)
21791                                                     {
21792                                                       /* 33222222222211111111110000000000
21793                                                          10987654321098765432109876543210
21794                                                          xx001110xx1xxxxx100101xxxxxxxxxx
21795                                                          mla.  */
21796                                                       return 285;
21797                                                     }
21798                                                   else
21799                                                     {
21800                                                       /* 33222222222211111111110000000000
21801                                                          10987654321098765432109876543210
21802                                                          xx101110xx1xxxxx100101xxxxxxxxxx
21803                                                          mls.  */
21804                                                       return 337;
21805                                                     }
21806                                                 }
21807                                               else
21808                                                 {
21809                                                   if (((word >> 23) & 0x1) == 0)
21810                                                     {
21811                                                       if (((word >> 29) & 0x1) == 0)
21812                                                         {
21813                                                           /* 33222222222211111111110000000000
21814                                                              10987654321098765432109876543210
21815                                                              xx0011100x1xxxxx110101xxxxxxxxxx
21816                                                              fadd.  */
21817                                                           return 295;
21818                                                         }
21819                                                       else
21820                                                         {
21821                                                           /* 33222222222211111111110000000000
21822                                                              10987654321098765432109876543210
21823                                                              xx1011100x1xxxxx110101xxxxxxxxxx
21824                                                              faddp.  */
21825                                                           return 344;
21826                                                         }
21827                                                     }
21828                                                   else
21829                                                     {
21830                                                       if (((word >> 29) & 0x1) == 0)
21831                                                         {
21832                                                           /* 33222222222211111111110000000000
21833                                                              10987654321098765432109876543210
21834                                                              xx0011101x1xxxxx110101xxxxxxxxxx
21835                                                              fsub.  */
21836                                                           return 311;
21837                                                         }
21838                                                       else
21839                                                         {
21840                                                           /* 33222222222211111111110000000000
21841                                                              10987654321098765432109876543210
21842                                                              xx1011101x1xxxxx110101xxxxxxxxxx
21843                                                              fabd.  */
21844                                                           return 360;
21845                                                         }
21846                                                     }
21847                                                 }
21848                                             }
21849                                           else
21850                                             {
21851                                               if (((word >> 14) & 0x1) == 0)
21852                                                 {
21853                                                   if (((word >> 29) & 0x1) == 0)
21854                                                     {
21855                                                       /* 33222222222211111111110000000000
21856                                                          10987654321098765432109876543210
21857                                                          xx001110xx1xxxxx101101xxxxxxxxxx
21858                                                          sqdmulh.  */
21859                                                       return 289;
21860                                                     }
21861                                                   else
21862                                                     {
21863                                                       /* 33222222222211111111110000000000
21864                                                          10987654321098765432109876543210
21865                                                          xx101110xx1xxxxx101101xxxxxxxxxx
21866                                                          sqrdmulh.  */
21867                                                       return 341;
21868                                                     }
21869                                                 }
21870                                               else
21871                                                 {
21872                                                   if (((word >> 23) & 0x1) == 0)
21873                                                     {
21874                                                       if (((word >> 29) & 0x1) == 0)
21875                                                         {
21876                                                           /* 33222222222211111111110000000000
21877                                                              10987654321098765432109876543210
21878                                                              xx0011100x1xxxxx111101xxxxxxxxxx
21879                                                              fmax.  */
21880                                                           return 301;
21881                                                         }
21882                                                       else
21883                                                         {
21884                                                           /* 33222222222211111111110000000000
21885                                                              10987654321098765432109876543210
21886                                                              xx1011100x1xxxxx111101xxxxxxxxxx
21887                                                              fmaxp.  */
21888                                                           return 352;
21889                                                         }
21890                                                     }
21891                                                   else
21892                                                     {
21893                                                       if (((word >> 29) & 0x1) == 0)
21894                                                         {
21895                                                           /* 33222222222211111111110000000000
21896                                                              10987654321098765432109876543210
21897                                                              xx0011101x1xxxxx111101xxxxxxxxxx
21898                                                              fmin.  */
21899                                                           return 313;
21900                                                         }
21901                                                       else
21902                                                         {
21903                                                           /* 33222222222211111111110000000000
21904                                                              10987654321098765432109876543210
21905                                                              xx1011101x1xxxxx111101xxxxxxxxxx
21906                                                              fminp.  */
21907                                                           return 366;
21908                                                         }
21909                                                     }
21910                                                 }
21911                                             }
21912                                         }
21913                                     }
21914                                   else
21915                                     {
21916                                       if (((word >> 12) & 0x1) == 0)
21917                                         {
21918                                           if (((word >> 13) & 0x1) == 0)
21919                                             {
21920                                               if (((word >> 14) & 0x1) == 0)
21921                                                 {
21922                                                   if (((word >> 29) & 0x1) == 0)
21923                                                     {
21924                                                       if (((word >> 31) & 0x1) == 0)
21925                                                         {
21926                                                           /* 33222222222211111111110000000000
21927                                                              10987654321098765432109876543210
21928                                                              0x001110xx1xxxxx100011xxxxxxxxxx
21929                                                              cmtst.  */
21930                                                           return 284;
21931                                                         }
21932                                                       else
21933                                                         {
21934                                                           /* 33222222222211111111110000000000
21935                                                              10987654321098765432109876543210
21936                                                              1x001110xx1xxxxx100011xxxxxxxxxx
21937                                                              rax1.  */
21938                                                           return 2424;
21939                                                         }
21940                                                     }
21941                                                   else
21942                                                     {
21943                                                       /* 33222222222211111111110000000000
21944                                                          10987654321098765432109876543210
21945                                                          xx101110xx1xxxxx100011xxxxxxxxxx
21946                                                          cmeq.  */
21947                                                       return 336;
21948                                                     }
21949                                                 }
21950                                               else
21951                                                 {
21952                                                   if (((word >> 23) & 0x1) == 0)
21953                                                     {
21954                                                       if (((word >> 29) & 0x1) == 0)
21955                                                         {
21956                                                           /* 33222222222211111111110000000000
21957                                                              10987654321098765432109876543210
21958                                                              xx0011100x1xxxxx110011xxxxxxxxxx
21959                                                              fmla.  */
21960                                                           return 293;
21961                                                         }
21962                                                       else
21963                                                         {
21964                                                           if (((word >> 30) & 0x1) == 0)
21965                                                             {
21966                                                               /* 33222222222211111111110000000000
21967                                                                  10987654321098765432109876543210
21968                                                                  x01011100x1xxxxx110011xxxxxxxxxx
21969                                                                  fmlal2.  */
21970                                                               return 2438;
21971                                                             }
21972                                                           else
21973                                                             {
21974                                                               /* 33222222222211111111110000000000
21975                                                                  10987654321098765432109876543210
21976                                                                  x11011100x1xxxxx110011xxxxxxxxxx
21977                                                                  fmlal2.  */
21978                                                               return 2442;
21979                                                             }
21980                                                         }
21981                                                     }
21982                                                   else
21983                                                     {
21984                                                       if (((word >> 29) & 0x1) == 0)
21985                                                         {
21986                                                           /* 33222222222211111111110000000000
21987                                                              10987654321098765432109876543210
21988                                                              xx0011101x1xxxxx110011xxxxxxxxxx
21989                                                              fmls.  */
21990                                                           return 309;
21991                                                         }
21992                                                       else
21993                                                         {
21994                                                           if (((word >> 30) & 0x1) == 0)
21995                                                             {
21996                                                               /* 33222222222211111111110000000000
21997                                                                  10987654321098765432109876543210
21998                                                                  x01011101x1xxxxx110011xxxxxxxxxx
21999                                                                  fmlsl2.  */
22000                                                               return 2439;
22001                                                             }
22002                                                           else
22003                                                             {
22004                                                               /* 33222222222211111111110000000000
22005                                                                  10987654321098765432109876543210
22006                                                                  x11011101x1xxxxx110011xxxxxxxxxx
22007                                                                  fmlsl2.  */
22008                                                               return 2443;
22009                                                             }
22010                                                         }
22011                                                     }
22012                                                 }
22013                                             }
22014                                           else
22015                                             {
22016                                               if (((word >> 14) & 0x1) == 0)
22017                                                 {
22018                                                   if (((word >> 29) & 0x1) == 0)
22019                                                     {
22020                                                       /* 33222222222211111111110000000000
22021                                                          10987654321098765432109876543210
22022                                                          xx001110xx1xxxxx101011xxxxxxxxxx
22023                                                          sminp.  */
22024                                                       return 288;
22025                                                     }
22026                                                   else
22027                                                     {
22028                                                       /* 33222222222211111111110000000000
22029                                                          10987654321098765432109876543210
22030                                                          xx101110xx1xxxxx101011xxxxxxxxxx
22031                                                          uminp.  */
22032                                                       return 340;
22033                                                     }
22034                                                 }
22035                                               else
22036                                                 {
22037                                                   if (((word >> 23) & 0x1) == 0)
22038                                                     {
22039                                                       if (((word >> 29) & 0x1) == 0)
22040                                                         {
22041                                                           if (((word >> 30) & 0x1) == 0)
22042                                                             {
22043                                                               /* 33222222222211111111110000000000
22044                                                                  10987654321098765432109876543210
22045                                                                  x00011100x1xxxxx111011xxxxxxxxxx
22046                                                                  fmlal.  */
22047                                                               return 2436;
22048                                                             }
22049                                                           else
22050                                                             {
22051                                                               /* 33222222222211111111110000000000
22052                                                                  10987654321098765432109876543210
22053                                                                  x10011100x1xxxxx111011xxxxxxxxxx
22054                                                                  fmlal.  */
22055                                                               return 2440;
22056                                                             }
22057                                                         }
22058                                                       else
22059                                                         {
22060                                                           /* 33222222222211111111110000000000
22061                                                              10987654321098765432109876543210
22062                                                              xx1011100x1xxxxx111011xxxxxxxxxx
22063                                                              facge.  */
22064                                                           return 350;
22065                                                         }
22066                                                     }
22067                                                   else
22068                                                     {
22069                                                       if (((word >> 29) & 0x1) == 0)
22070                                                         {
22071                                                           if (((word >> 30) & 0x1) == 0)
22072                                                             {
22073                                                               /* 33222222222211111111110000000000
22074                                                                  10987654321098765432109876543210
22075                                                                  x00011101x1xxxxx111011xxxxxxxxxx
22076                                                                  fmlsl.  */
22077                                                               return 2437;
22078                                                             }
22079                                                           else
22080                                                             {
22081                                                               /* 33222222222211111111110000000000
22082                                                                  10987654321098765432109876543210
22083                                                                  x10011101x1xxxxx111011xxxxxxxxxx
22084                                                                  fmlsl.  */
22085                                                               return 2441;
22086                                                             }
22087                                                         }
22088                                                       else
22089                                                         {
22090                                                           /* 33222222222211111111110000000000
22091                                                              10987654321098765432109876543210
22092                                                              xx1011101x1xxxxx111011xxxxxxxxxx
22093                                                              facgt.  */
22094                                                           return 364;
22095                                                         }
22096                                                     }
22097                                                 }
22098                                             }
22099                                         }
22100                                       else
22101                                         {
22102                                           if (((word >> 13) & 0x1) == 0)
22103                                             {
22104                                               if (((word >> 14) & 0x1) == 0)
22105                                                 {
22106                                                   if (((word >> 29) & 0x1) == 0)
22107                                                     {
22108                                                       /* 33222222222211111111110000000000
22109                                                          10987654321098765432109876543210
22110                                                          xx001110xx1xxxxx100111xxxxxxxxxx
22111                                                          mul.  */
22112                                                       return 286;
22113                                                     }
22114                                                   else
22115                                                     {
22116                                                       /* 33222222222211111111110000000000
22117                                                          10987654321098765432109876543210
22118                                                          xx101110xx1xxxxx100111xxxxxxxxxx
22119                                                          pmul.  */
22120                                                       return 338;
22121                                                     }
22122                                                 }
22123                                               else
22124                                                 {
22125                                                   if (((word >> 29) & 0x1) == 0)
22126                                                     {
22127                                                       /* 33222222222211111111110000000000
22128                                                          10987654321098765432109876543210
22129                                                          xx001110xx1xxxxx110111xxxxxxxxxx
22130                                                          fmulx.  */
22131                                                       return 297;
22132                                                     }
22133                                                   else
22134                                                     {
22135                                                       /* 33222222222211111111110000000000
22136                                                          10987654321098765432109876543210
22137                                                          xx101110xx1xxxxx110111xxxxxxxxxx
22138                                                          fmul.  */
22139                                                       return 346;
22140                                                     }
22141                                                 }
22142                                             }
22143                                           else
22144                                             {
22145                                               if (((word >> 14) & 0x1) == 0)
22146                                                 {
22147                                                   /* 33222222222211111111110000000000
22148                                                      10987654321098765432109876543210
22149                                                      xxx01110xx1xxxxx101111xxxxxxxxxx
22150                                                      addp.  */
22151                                                   return 290;
22152                                                 }
22153                                               else
22154                                                 {
22155                                                   if (((word >> 23) & 0x1) == 0)
22156                                                     {
22157                                                       if (((word >> 29) & 0x1) == 0)
22158                                                         {
22159                                                           /* 33222222222211111111110000000000
22160                                                              10987654321098765432109876543210
22161                                                              xx0011100x1xxxxx111111xxxxxxxxxx
22162                                                              frecps.  */
22163                                                           return 303;
22164                                                         }
22165                                                       else
22166                                                         {
22167                                                           /* 33222222222211111111110000000000
22168                                                              10987654321098765432109876543210
22169                                                              xx1011100x1xxxxx111111xxxxxxxxxx
22170                                                              fdiv.  */
22171                                                           return 354;
22172                                                         }
22173                                                     }
22174                                                   else
22175                                                     {
22176                                                       /* 33222222222211111111110000000000
22177                                                          10987654321098765432109876543210
22178                                                          xxx011101x1xxxxx111111xxxxxxxxxx
22179                                                          frsqrts.  */
22180                                                       return 315;
22181                                                     }
22182                                                 }
22183                                             }
22184                                         }
22185                                     }
22186                                 }
22187                             }
22188                         }
22189                       else
22190                         {
22191                           if (((word >> 10) & 0x1) == 0)
22192                             {
22193                               if (((word >> 11) & 0x1) == 0)
22194                                 {
22195                                   if (((word >> 12) & 0x1) == 0)
22196                                     {
22197                                       if (((word >> 13) & 0x1) == 0)
22198                                         {
22199                                           if (((word >> 14) & 0x1) == 0)
22200                                             {
22201                                               if (((word >> 16) & 0x1) == 0)
22202                                                 {
22203                                                   if (((word >> 17) & 0x1) == 0)
22204                                                     {
22205                                                       if (((word >> 18) & 0x1) == 0)
22206                                                         {
22207                                                           if (((word >> 19) & 0x1) == 0)
22208                                                             {
22209                                                               if (((word >> 20) & 0x1) == 0)
22210                                                                 {
22211                                                                   /* 33222222222211111111110000000000
22212                                                                      10987654321098765432109876543210
22213                                                                      xxx11110xx100000x00000xxxxxxxxxx
22214                                                                      fcvtns.  */
22215                                                                   return 768;
22216                                                                 }
22217                                                               else
22218                                                                 {
22219                                                                   /* 33222222222211111111110000000000
22220                                                                      10987654321098765432109876543210
22221                                                                      xxx11110xx110000x00000xxxxxxxxxx
22222                                                                      fcvtms.  */
22223                                                                   return 788;
22224                                                                 }
22225                                                             }
22226                                                           else
22227                                                             {
22228                                                               if (((word >> 20) & 0x1) == 0)
22229                                                                 {
22230                                                                   /* 33222222222211111111110000000000
22231                                                                      10987654321098765432109876543210
22232                                                                      xxx11110xx101000x00000xxxxxxxxxx
22233                                                                      fcvtps.  */
22234                                                                   return 784;
22235                                                                 }
22236                                                               else
22237                                                                 {
22238                                                                   /* 33222222222211111111110000000000
22239                                                                      10987654321098765432109876543210
22240                                                                      xxx11110xx111000x00000xxxxxxxxxx
22241                                                                      fcvtzs.  */
22242                                                                   return 792;
22243                                                                 }
22244                                                             }
22245                                                         }
22246                                                       else
22247                                                         {
22248                                                           /* 33222222222211111111110000000000
22249                                                              10987654321098765432109876543210
22250                                                              xxx11110xx1xx100x00000xxxxxxxxxx
22251                                                              fcvtas.  */
22252                                                           return 776;
22253                                                         }
22254                                                     }
22255                                                   else
22256                                                     {
22257                                                       if (((word >> 18) & 0x1) == 0)
22258                                                         {
22259                                                           /* 33222222222211111111110000000000
22260                                                              10987654321098765432109876543210
22261                                                              xxx11110xx1xx010x00000xxxxxxxxxx
22262                                                              scvtf.  */
22263                                                           return 772;
22264                                                         }
22265                                                       else
22266                                                         {
22267                                                           if (((word >> 19) & 0x1) == 0)
22268                                                             {
22269                                                               /* 33222222222211111111110000000000
22270                                                                  10987654321098765432109876543210
22271                                                                  xxx11110xx1x0110x00000xxxxxxxxxx
22272                                                                  fmov.  */
22273                                                               return 780;
22274                                                             }
22275                                                           else
22276                                                             {
22277                                                               if (((word >> 20) & 0x1) == 0)
22278                                                                 {
22279                                                                   /* 33222222222211111111110000000000
22280                                                                      10987654321098765432109876543210
22281                                                                      xxx11110xx101110x00000xxxxxxxxxx
22282                                                                      fmov.  */
22283                                                                   return 796;
22284                                                                 }
22285                                                               else
22286                                                                 {
22287                                                                   /* 33222222222211111111110000000000
22288                                                                      10987654321098765432109876543210
22289                                                                      xxx11110xx111110x00000xxxxxxxxxx
22290                                                                      fjcvtzs.  */
22291                                                                   return 798;
22292                                                                 }
22293                                                             }
22294                                                         }
22295                                                     }
22296                                                 }
22297                                               else
22298                                                 {
22299                                                   if (((word >> 17) & 0x1) == 0)
22300                                                     {
22301                                                       if (((word >> 18) & 0x1) == 0)
22302                                                         {
22303                                                           if (((word >> 19) & 0x1) == 0)
22304                                                             {
22305                                                               if (((word >> 20) & 0x1) == 0)
22306                                                                 {
22307                                                                   /* 33222222222211111111110000000000
22308                                                                      10987654321098765432109876543210
22309                                                                      xxx11110xx100001x00000xxxxxxxxxx
22310                                                                      fcvtnu.  */
22311                                                                   return 770;
22312                                                                 }
22313                                                               else
22314                                                                 {
22315                                                                   /* 33222222222211111111110000000000
22316                                                                      10987654321098765432109876543210
22317                                                                      xxx11110xx110001x00000xxxxxxxxxx
22318                                                                      fcvtmu.  */
22319                                                                   return 790;
22320                                                                 }
22321                                                             }
22322                                                           else
22323                                                             {
22324                                                               if (((word >> 20) & 0x1) == 0)
22325                                                                 {
22326                                                                   /* 33222222222211111111110000000000
22327                                                                      10987654321098765432109876543210
22328                                                                      xxx11110xx101001x00000xxxxxxxxxx
22329                                                                      fcvtpu.  */
22330                                                                   return 786;
22331                                                                 }
22332                                                               else
22333                                                                 {
22334                                                                   /* 33222222222211111111110000000000
22335                                                                      10987654321098765432109876543210
22336                                                                      xxx11110xx111001x00000xxxxxxxxxx
22337                                                                      fcvtzu.  */
22338                                                                   return 794;
22339                                                                 }
22340                                                             }
22341                                                         }
22342                                                       else
22343                                                         {
22344                                                           /* 33222222222211111111110000000000
22345                                                              10987654321098765432109876543210
22346                                                              xxx11110xx1xx101x00000xxxxxxxxxx
22347                                                              fcvtau.  */
22348                                                           return 778;
22349                                                         }
22350                                                     }
22351                                                   else
22352                                                     {
22353                                                       if (((word >> 18) & 0x1) == 0)
22354                                                         {
22355                                                           /* 33222222222211111111110000000000
22356                                                              10987654321098765432109876543210
22357                                                              xxx11110xx1xx011x00000xxxxxxxxxx
22358                                                              ucvtf.  */
22359                                                           return 774;
22360                                                         }
22361                                                       else
22362                                                         {
22363                                                           if (((word >> 19) & 0x1) == 0)
22364                                                             {
22365                                                               /* 33222222222211111111110000000000
22366                                                                  10987654321098765432109876543210
22367                                                                  xxx11110xx1x0111x00000xxxxxxxxxx
22368                                                                  fmov.  */
22369                                                               return 782;
22370                                                             }
22371                                                           else
22372                                                             {
22373                                                               /* 33222222222211111111110000000000
22374                                                                  10987654321098765432109876543210
22375                                                                  xxx11110xx1x1111x00000xxxxxxxxxx
22376                                                                  fmov.  */
22377                                                               return 797;
22378                                                             }
22379                                                         }
22380                                                     }
22381                                                 }
22382                                             }
22383                                           else
22384                                             {
22385                                               if (((word >> 17) & 0x1) == 0)
22386                                                 {
22387                                                   if (((word >> 15) & 0x1) == 0)
22388                                                     {
22389                                                       if (((word >> 16) & 0x1) == 0)
22390                                                         {
22391                                                           if (((word >> 18) & 0x1) == 0)
22392                                                             {
22393                                                               if (((word >> 19) & 0x1) == 0)
22394                                                                 {
22395                                                                   /* 33222222222211111111110000000000
22396                                                                      10987654321098765432109876543210
22397                                                                      xxx11110xx1x0000010000xxxxxxxxxx
22398                                                                      fmov.  */
22399                                                                   return 817;
22400                                                                 }
22401                                                               else
22402                                                                 {
22403                                                                   /* 33222222222211111111110000000000
22404                                                                      10987654321098765432109876543210
22405                                                                      xxx11110xx1x1000010000xxxxxxxxxx
22406                                                                      frint32z.  */
22407                                                                   return 813;
22408                                                                 }
22409                                                             }
22410                                                           else
22411                                                             {
22412                                                               /* 33222222222211111111110000000000
22413                                                                  10987654321098765432109876543210
22414                                                                  xxx11110xx1xx100010000xxxxxxxxxx
22415                                                                  frintn.  */
22416                                                               return 826;
22417                                                             }
22418                                                         }
22419                                                       else
22420                                                         {
22421                                                           if (((word >> 18) & 0x1) == 0)
22422                                                             {
22423                                                               if (((word >> 19) & 0x1) == 0)
22424                                                                 {
22425                                                                   /* 33222222222211111111110000000000
22426                                                                      10987654321098765432109876543210
22427                                                                      xxx11110xx1x0001010000xxxxxxxxxx
22428                                                                      fneg.  */
22429                                                                   return 821;
22430                                                                 }
22431                                                               else
22432                                                                 {
22433                                                                   /* 33222222222211111111110000000000
22434                                                                      10987654321098765432109876543210
22435                                                                      xxx11110xx1x1001010000xxxxxxxxxx
22436                                                                      frint64z.  */
22437                                                                   return 815;
22438                                                                 }
22439                                                             }
22440                                                           else
22441                                                             {
22442                                                               /* 33222222222211111111110000000000
22443                                                                  10987654321098765432109876543210
22444                                                                  xxx11110xx1xx101010000xxxxxxxxxx
22445                                                                  frintm.  */
22446                                                               return 830;
22447                                                             }
22448                                                         }
22449                                                     }
22450                                                   else
22451                                                     {
22452                                                       if (((word >> 16) & 0x1) == 0)
22453                                                         {
22454                                                           if (((word >> 18) & 0x1) == 0)
22455                                                             {
22456                                                               if (((word >> 19) & 0x1) == 0)
22457                                                                 {
22458                                                                   /* 33222222222211111111110000000000
22459                                                                      10987654321098765432109876543210
22460                                                                      xxx11110xx1x0000110000xxxxxxxxxx
22461                                                                      fabs.  */
22462                                                                   return 819;
22463                                                                 }
22464                                                               else
22465                                                                 {
22466                                                                   /* 33222222222211111111110000000000
22467                                                                      10987654321098765432109876543210
22468                                                                      xxx11110xx1x1000110000xxxxxxxxxx
22469                                                                      frint32x.  */
22470                                                                   return 814;
22471                                                                 }
22472                                                             }
22473                                                           else
22474                                                             {
22475                                                               /* 33222222222211111111110000000000
22476                                                                  10987654321098765432109876543210
22477                                                                  xxx11110xx1xx100110000xxxxxxxxxx
22478                                                                  frintp.  */
22479                                                               return 828;
22480                                                             }
22481                                                         }
22482                                                       else
22483                                                         {
22484                                                           if (((word >> 18) & 0x1) == 0)
22485                                                             {
22486                                                               if (((word >> 19) & 0x1) == 0)
22487                                                                 {
22488                                                                   /* 33222222222211111111110000000000
22489                                                                      10987654321098765432109876543210
22490                                                                      xxx11110xx1x0001110000xxxxxxxxxx
22491                                                                      fsqrt.  */
22492                                                                   return 823;
22493                                                                 }
22494                                                               else
22495                                                                 {
22496                                                                   /* 33222222222211111111110000000000
22497                                                                      10987654321098765432109876543210
22498                                                                      xxx11110xx1x1001110000xxxxxxxxxx
22499                                                                      frint64x.  */
22500                                                                   return 816;
22501                                                                 }
22502                                                             }
22503                                                           else
22504                                                             {
22505                                                               /* 33222222222211111111110000000000
22506                                                                  10987654321098765432109876543210
22507                                                                  xxx11110xx1xx101110000xxxxxxxxxx
22508                                                                  frintz.  */
22509                                                               return 832;
22510                                                             }
22511                                                         }
22512                                                     }
22513                                                 }
22514                                               else
22515                                                 {
22516                                                   if (((word >> 18) & 0x1) == 0)
22517                                                     {
22518                                                       /* 33222222222211111111110000000000
22519                                                          10987654321098765432109876543210
22520                                                          xxx11110xx1xx01xx10000xxxxxxxxxx
22521                                                          fcvt.  */
22522                                                       return 825;
22523                                                     }
22524                                                   else
22525                                                     {
22526                                                       if (((word >> 15) & 0x1) == 0)
22527                                                         {
22528                                                           if (((word >> 16) & 0x1) == 0)
22529                                                             {
22530                                                               /* 33222222222211111111110000000000
22531                                                                  10987654321098765432109876543210
22532                                                                  xxx11110xx1xx110010000xxxxxxxxxx
22533                                                                  frinta.  */
22534                                                               return 834;
22535                                                             }
22536                                                           else
22537                                                             {
22538                                                               /* 33222222222211111111110000000000
22539                                                                  10987654321098765432109876543210
22540                                                                  xxx11110xx1xx111010000xxxxxxxxxx
22541                                                                  frintx.  */
22542                                                               return 836;
22543                                                             }
22544                                                         }
22545                                                       else
22546                                                         {
22547                                                           /* 33222222222211111111110000000000
22548                                                              10987654321098765432109876543210
22549                                                              xxx11110xx1xx11x110000xxxxxxxxxx
22550                                                              frinti.  */
22551                                                           return 838;
22552                                                         }
22553                                                     }
22554                                                 }
22555                                             }
22556                                         }
22557                                       else
22558                                         {
22559                                           if (((word >> 3) & 0x1) == 0)
22560                                             {
22561                                               if (((word >> 4) & 0x1) == 0)
22562                                                 {
22563                                                   /* 33222222222211111111110000000000
22564                                                      10987654321098765432109876543210
22565                                                      xxx11110xx1xxxxxxx1000xxxxx00xxx
22566                                                      fcmp.  */
22567                                                   return 803;
22568                                                 }
22569                                               else
22570                                                 {
22571                                                   /* 33222222222211111111110000000000
22572                                                      10987654321098765432109876543210
22573                                                      xxx11110xx1xxxxxxx1000xxxxx10xxx
22574                                                      fcmpe.  */
22575                                                   return 805;
22576                                                 }
22577                                             }
22578                                           else
22579                                             {
22580                                               if (((word >> 4) & 0x1) == 0)
22581                                                 {
22582                                                   /* 33222222222211111111110000000000
22583                                                      10987654321098765432109876543210
22584                                                      xxx11110xx1xxxxxxx1000xxxxx01xxx
22585                                                      fcmp.  */
22586                                                   return 807;
22587                                                 }
22588                                               else
22589                                                 {
22590                                                   /* 33222222222211111111110000000000
22591                                                      10987654321098765432109876543210
22592                                                      xxx11110xx1xxxxxxx1000xxxxx11xxx
22593                                                      fcmpe.  */
22594                                                   return 809;
22595                                                 }
22596                                             }
22597                                         }
22598                                     }
22599                                   else
22600                                     {
22601                                       if (((word >> 30) & 0x1) == 0)
22602                                         {
22603                                           /* 33222222222211111111110000000000
22604                                              10987654321098765432109876543210
22605                                              x0x11110xx1xxxxxxxx100xxxxxxxxxx
22606                                              fmov.  */
22607                                           return 866;
22608                                         }
22609                                       else
22610                                         {
22611                                           if (((word >> 13) & 0x1) == 0)
22612                                             {
22613                                               if (((word >> 14) & 0x1) == 0)
22614                                                 {
22615                                                   /* 33222222222211111111110000000000
22616                                                      10987654321098765432109876543210
22617                                                      x1x11110xx1xxxxxx00100xxxxxxxxxx
22618                                                      sqdmlal.  */
22619                                                   return 422;
22620                                                 }
22621                                               else
22622                                                 {
22623                                                   /* 33222222222211111111110000000000
22624                                                      10987654321098765432109876543210
22625                                                      x1x11110xx1xxxxxx10100xxxxxxxxxx
22626                                                      sqdmull.  */
22627                                                   return 424;
22628                                                 }
22629                                             }
22630                                           else
22631                                             {
22632                                               /* 33222222222211111111110000000000
22633                                                  10987654321098765432109876543210
22634                                                  x1x11110xx1xxxxxxx1100xxxxxxxxxx
22635                                                  sqdmlsl.  */
22636                                               return 423;
22637                                             }
22638                                         }
22639                                     }
22640                                 }
22641                               else
22642                                 {
22643                                   if (((word >> 12) & 0x1) == 0)
22644                                     {
22645                                       if (((word >> 13) & 0x1) == 0)
22646                                         {
22647                                           if (((word >> 14) & 0x1) == 0)
22648                                             {
22649                                               if (((word >> 15) & 0x1) == 0)
22650                                                 {
22651                                                   if (((word >> 30) & 0x1) == 0)
22652                                                     {
22653                                                       /* 33222222222211111111110000000000
22654                                                          10987654321098765432109876543210
22655                                                          x0x11110xx1xxxxx000010xxxxxxxxxx
22656                                                          fmul.  */
22657                                                       return 840;
22658                                                     }
22659                                                   else
22660                                                     {
22661                                                       /* 33222222222211111111110000000000
22662                                                          10987654321098765432109876543210
22663                                                          x1x11110xx1xxxxx000010xxxxxxxxxx
22664                                                          sha1h.  */
22665                                                       return 675;
22666                                                     }
22667                                                 }
22668                                               else
22669                                                 {
22670                                                   if (((word >> 29) & 0x1) == 0)
22671                                                     {
22672                                                       if (((word >> 30) & 0x1) == 0)
22673                                                         {
22674                                                           /* 33222222222211111111110000000000
22675                                                              10987654321098765432109876543210
22676                                                              x0011110xx1xxxxx100010xxxxxxxxxx
22677                                                              fnmul.  */
22678                                                           return 856;
22679                                                         }
22680                                                       else
22681                                                         {
22682                                                           /* 33222222222211111111110000000000
22683                                                              10987654321098765432109876543210
22684                                                              x1011110xx1xxxxx100010xxxxxxxxxx
22685                                                              cmgt.  */
22686                                                           return 482;
22687                                                         }
22688                                                     }
22689                                                   else
22690                                                     {
22691                                                       /* 33222222222211111111110000000000
22692                                                          10987654321098765432109876543210
22693                                                          xx111110xx1xxxxx100010xxxxxxxxxx
22694                                                          cmge.  */
22695                                                       return 511;
22696                                                     }
22697                                                 }
22698                                             }
22699                                           else
22700                                             {
22701                                               if (((word >> 15) & 0x1) == 0)
22702                                                 {
22703                                                   if (((word >> 29) & 0x1) == 0)
22704                                                     {
22705                                                       if (((word >> 30) & 0x1) == 0)
22706                                                         {
22707                                                           /* 33222222222211111111110000000000
22708                                                              10987654321098765432109876543210
22709                                                              x0011110xx1xxxxx010010xxxxxxxxxx
22710                                                              fmax.  */
22711                                                           return 848;
22712                                                         }
22713                                                       else
22714                                                         {
22715                                                           /* 33222222222211111111110000000000
22716                                                              10987654321098765432109876543210
22717                                                              x1011110xx1xxxxx010010xxxxxxxxxx
22718                                                              sqxtn.  */
22719                                                           return 486;
22720                                                         }
22721                                                     }
22722                                                   else
22723                                                     {
22724                                                       /* 33222222222211111111110000000000
22725                                                          10987654321098765432109876543210
22726                                                          xx111110xx1xxxxx010010xxxxxxxxxx
22727                                                          uqxtn.  */
22728                                                       return 515;
22729                                                     }
22730                                                 }
22731                                               else
22732                                                 {
22733                                                   if (((word >> 16) & 0x1) == 0)
22734                                                     {
22735                                                       if (((word >> 19) & 0x1) == 0)
22736                                                         {
22737                                                           if (((word >> 20) & 0x1) == 0)
22738                                                             {
22739                                                               if (((word >> 29) & 0x1) == 0)
22740                                                                 {
22741                                                                   /* 33222222222211111111110000000000
22742                                                                      10987654321098765432109876543210
22743                                                                      xx011110xx100xx0110010xxxxxxxxxx
22744                                                                      fcmgt.  */
22745                                                                   return 495;
22746                                                                 }
22747                                                               else
22748                                                                 {
22749                                                                   /* 33222222222211111111110000000000
22750                                                                      10987654321098765432109876543210
22751                                                                      xx111110xx100xx0110010xxxxxxxxxx
22752                                                                      fcmge.  */
22753                                                                   return 525;
22754                                                                 }
22755                                                             }
22756                                                           else
22757                                                             {
22758                                                               if (((word >> 23) & 0x1) == 0)
22759                                                                 {
22760                                                                   if (((word >> 29) & 0x1) == 0)
22761                                                                     {
22762                                                                       /* 33222222222211111111110000000000
22763                                                                          10987654321098765432109876543210
22764                                                                          xx0111100x110xx0110010xxxxxxxxxx
22765                                                                          fmaxnmp.  */
22766                                                                       return 539;
22767                                                                     }
22768                                                                   else
22769                                                                     {
22770                                                                       /* 33222222222211111111110000000000
22771                                                                          10987654321098765432109876543210
22772                                                                          xx1111100x110xx0110010xxxxxxxxxx
22773                                                                          fmaxnmp.  */
22774                                                                       return 538;
22775                                                                     }
22776                                                                 }
22777                                                               else
22778                                                                 {
22779                                                                   if (((word >> 29) & 0x1) == 0)
22780                                                                     {
22781                                                                       /* 33222222222211111111110000000000
22782                                                                          10987654321098765432109876543210
22783                                                                          xx0111101x110xx0110010xxxxxxxxxx
22784                                                                          fminnmp.  */
22785                                                                       return 545;
22786                                                                     }
22787                                                                   else
22788                                                                     {
22789                                                                       /* 33222222222211111111110000000000
22790                                                                          10987654321098765432109876543210
22791                                                                          xx1111101x110xx0110010xxxxxxxxxx
22792                                                                          fminnmp.  */
22793                                                                       return 544;
22794                                                                     }
22795                                                                 }
22796                                                             }
22797                                                         }
22798                                                       else
22799                                                         {
22800                                                           if (((word >> 29) & 0x1) == 0)
22801                                                             {
22802                                                               /* 33222222222211111111110000000000
22803                                                                  10987654321098765432109876543210
22804                                                                  xx011110xx1x1xx0110010xxxxxxxxxx
22805                                                                  fcmgt.  */
22806                                                               return 496;
22807                                                             }
22808                                                           else
22809                                                             {
22810                                                               /* 33222222222211111111110000000000
22811                                                                  10987654321098765432109876543210
22812                                                                  xx111110xx1x1xx0110010xxxxxxxxxx
22813                                                                  fcmge.  */
22814                                                               return 526;
22815                                                             }
22816                                                         }
22817                                                     }
22818                                                   else
22819                                                     {
22820                                                       if (((word >> 19) & 0x1) == 0)
22821                                                         {
22822                                                           if (((word >> 29) & 0x1) == 0)
22823                                                             {
22824                                                               /* 33222222222211111111110000000000
22825                                                                  10987654321098765432109876543210
22826                                                                  xx011110xx1x0xx1110010xxxxxxxxxx
22827                                                                  fcvtas.  */
22828                                                               return 491;
22829                                                             }
22830                                                           else
22831                                                             {
22832                                                               /* 33222222222211111111110000000000
22833                                                                  10987654321098765432109876543210
22834                                                                  xx111110xx1x0xx1110010xxxxxxxxxx
22835                                                                  fcvtau.  */
22836                                                               return 521;
22837                                                             }
22838                                                         }
22839                                                       else
22840                                                         {
22841                                                           if (((word >> 29) & 0x1) == 0)
22842                                                             {
22843                                                               /* 33222222222211111111110000000000
22844                                                                  10987654321098765432109876543210
22845                                                                  xx011110xx1x1xx1110010xxxxxxxxxx
22846                                                                  fcvtas.  */
22847                                                               return 492;
22848                                                             }
22849                                                           else
22850                                                             {
22851                                                               /* 33222222222211111111110000000000
22852                                                                  10987654321098765432109876543210
22853                                                                  xx111110xx1x1xx1110010xxxxxxxxxx
22854                                                                  fcvtau.  */
22855                                                               return 522;
22856                                                             }
22857                                                         }
22858                                                     }
22859                                                 }
22860                                             }
22861                                         }
22862                                       else
22863                                         {
22864                                           if (((word >> 14) & 0x1) == 0)
22865                                             {
22866                                               if (((word >> 15) & 0x1) == 0)
22867                                                 {
22868                                                   if (((word >> 29) & 0x1) == 0)
22869                                                     {
22870                                                       if (((word >> 30) & 0x1) == 0)
22871                                                         {
22872                                                           /* 33222222222211111111110000000000
22873                                                              10987654321098765432109876543210
22874                                                              x0011110xx1xxxxx001010xxxxxxxxxx
22875                                                              fadd.  */
22876                                                           return 844;
22877                                                         }
22878                                                       else
22879                                                         {
22880                                                           /* 33222222222211111111110000000000
22881                                                              10987654321098765432109876543210
22882                                                              x1011110xx1xxxxx001010xxxxxxxxxx
22883                                                              sha256su0.  */
22884                                                           return 677;
22885                                                         }
22886                                                     }
22887                                                   else
22888                                                     {
22889                                                       /* 33222222222211111111110000000000
22890                                                          10987654321098765432109876543210
22891                                                          xx111110xx1xxxxx001010xxxxxxxxxx
22892                                                          sqxtun.  */
22893                                                       return 514;
22894                                                     }
22895                                                 }
22896                                               else
22897                                                 {
22898                                                   if (((word >> 16) & 0x1) == 0)
22899                                                     {
22900                                                       /* 33222222222211111111110000000000
22901                                                          10987654321098765432109876543210
22902                                                          xxx11110xx1xxxx0101010xxxxxxxxxx
22903                                                          cmlt.  */
22904                                                       return 484;
22905                                                     }
22906                                                   else
22907                                                     {
22908                                                       if (((word >> 19) & 0x1) == 0)
22909                                                         {
22910                                                           if (((word >> 23) & 0x1) == 0)
22911                                                             {
22912                                                               if (((word >> 29) & 0x1) == 0)
22913                                                                 {
22914                                                                   /* 33222222222211111111110000000000
22915                                                                      10987654321098765432109876543210
22916                                                                      xx0111100x1x0xx1101010xxxxxxxxxx
22917                                                                      fcvtns.  */
22918                                                                   return 487;
22919                                                                 }
22920                                                               else
22921                                                                 {
22922                                                                   /* 33222222222211111111110000000000
22923                                                                      10987654321098765432109876543210
22924                                                                      xx1111100x1x0xx1101010xxxxxxxxxx
22925                                                                      fcvtnu.  */
22926                                                                   return 517;
22927                                                                 }
22928                                                             }
22929                                                           else
22930                                                             {
22931                                                               if (((word >> 29) & 0x1) == 0)
22932                                                                 {
22933                                                                   /* 33222222222211111111110000000000
22934                                                                      10987654321098765432109876543210
22935                                                                      xx0111101x1x0xx1101010xxxxxxxxxx
22936                                                                      fcvtps.  */
22937                                                                   return 501;
22938                                                                 }
22939                                                               else
22940                                                                 {
22941                                                                   /* 33222222222211111111110000000000
22942                                                                      10987654321098765432109876543210
22943                                                                      xx1111101x1x0xx1101010xxxxxxxxxx
22944                                                                      fcvtpu.  */
22945                                                                   return 529;
22946                                                                 }
22947                                                             }
22948                                                         }
22949                                                       else
22950                                                         {
22951                                                           if (((word >> 23) & 0x1) == 0)
22952                                                             {
22953                                                               if (((word >> 29) & 0x1) == 0)
22954                                                                 {
22955                                                                   /* 33222222222211111111110000000000
22956                                                                      10987654321098765432109876543210
22957                                                                      xx0111100x1x1xx1101010xxxxxxxxxx
22958                                                                      fcvtns.  */
22959                                                                   return 488;
22960                                                                 }
22961                                                               else
22962                                                                 {
22963                                                                   /* 33222222222211111111110000000000
22964                                                                      10987654321098765432109876543210
22965                                                                      xx1111100x1x1xx1101010xxxxxxxxxx
22966                                                                      fcvtnu.  */
22967                                                                   return 518;
22968                                                                 }
22969                                                             }
22970                                                           else
22971                                                             {
22972                                                               if (((word >> 29) & 0x1) == 0)
22973                                                                 {
22974                                                                   /* 33222222222211111111110000000000
22975                                                                      10987654321098765432109876543210
22976                                                                      xx0111101x1x1xx1101010xxxxxxxxxx
22977                                                                      fcvtps.  */
22978                                                                   return 502;
22979                                                                 }
22980                                                               else
22981                                                                 {
22982                                                                   /* 33222222222211111111110000000000
22983                                                                      10987654321098765432109876543210
22984                                                                      xx1111101x1x1xx1101010xxxxxxxxxx
22985                                                                      fcvtpu.  */
22986                                                                   return 530;
22987                                                                 }
22988                                                             }
22989                                                         }
22990                                                     }
22991                                                 }
22992                                             }
22993                                           else
22994                                             {
22995                                               if (((word >> 15) & 0x1) == 0)
22996                                                 {
22997                                                   if (((word >> 29) & 0x1) == 0)
22998                                                     {
22999                                                       /* 33222222222211111111110000000000
23000                                                          10987654321098765432109876543210
23001                                                          xx011110xx1xxxxx011010xxxxxxxxxx
23002                                                          fmaxnm.  */
23003                                                       return 852;
23004                                                     }
23005                                                   else
23006                                                     {
23007                                                       /* 33222222222211111111110000000000
23008                                                          10987654321098765432109876543210
23009                                                          xx111110xx1xxxxx011010xxxxxxxxxx
23010                                                          fcvtxn.  */
23011                                                       return 516;
23012                                                     }
23013                                                 }
23014                                               else
23015                                                 {
23016                                                   if (((word >> 19) & 0x1) == 0)
23017                                                     {
23018                                                       /* 33222222222211111111110000000000
23019                                                          10987654321098765432109876543210
23020                                                          xxx11110xx1x0xxx111010xxxxxxxxxx
23021                                                          fcmlt.  */
23022                                                       return 499;
23023                                                     }
23024                                                   else
23025                                                     {
23026                                                       /* 33222222222211111111110000000000
23027                                                          10987654321098765432109876543210
23028                                                          xxx11110xx1x1xxx111010xxxxxxxxxx
23029                                                          fcmlt.  */
23030                                                       return 500;
23031                                                     }
23032                                                 }
23033                                             }
23034                                         }
23035                                     }
23036                                   else
23037                                     {
23038                                       if (((word >> 13) & 0x1) == 0)
23039                                         {
23040                                           if (((word >> 14) & 0x1) == 0)
23041                                             {
23042                                               if (((word >> 15) & 0x1) == 0)
23043                                                 {
23044                                                   if (((word >> 30) & 0x1) == 0)
23045                                                     {
23046                                                       /* 33222222222211111111110000000000
23047                                                          10987654321098765432109876543210
23048                                                          x0x11110xx1xxxxx000110xxxxxxxxxx
23049                                                          fdiv.  */
23050                                                       return 842;
23051                                                     }
23052                                                   else
23053                                                     {
23054                                                       /* 33222222222211111111110000000000
23055                                                          10987654321098765432109876543210
23056                                                          x1x11110xx1xxxxx000110xxxxxxxxxx
23057                                                          sha1su1.  */
23058                                                       return 676;
23059                                                     }
23060                                                 }
23061                                               else
23062                                                 {
23063                                                   if (((word >> 29) & 0x1) == 0)
23064                                                     {
23065                                                       /* 33222222222211111111110000000000
23066                                                          10987654321098765432109876543210
23067                                                          xx011110xx1xxxxx100110xxxxxxxxxx
23068                                                          cmeq.  */
23069                                                       return 483;
23070                                                     }
23071                                                   else
23072                                                     {
23073                                                       /* 33222222222211111111110000000000
23074                                                          10987654321098765432109876543210
23075                                                          xx111110xx1xxxxx100110xxxxxxxxxx
23076                                                          cmle.  */
23077                                                       return 512;
23078                                                     }
23079                                                 }
23080                                             }
23081                                           else
23082                                             {
23083                                               if (((word >> 15) & 0x1) == 0)
23084                                                 {
23085                                                   /* 33222222222211111111110000000000
23086                                                      10987654321098765432109876543210
23087                                                      xxx11110xx1xxxxx010110xxxxxxxxxx
23088                                                      fmin.  */
23089                                                   return 850;
23090                                                 }
23091                                               else
23092                                                 {
23093                                                   if (((word >> 16) & 0x1) == 0)
23094                                                     {
23095                                                       if (((word >> 19) & 0x1) == 0)
23096                                                         {
23097                                                           if (((word >> 20) & 0x1) == 0)
23098                                                             {
23099                                                               if (((word >> 29) & 0x1) == 0)
23100                                                                 {
23101                                                                   /* 33222222222211111111110000000000
23102                                                                      10987654321098765432109876543210
23103                                                                      xx011110xx100xx0110110xxxxxxxxxx
23104                                                                      fcmeq.  */
23105                                                                   return 497;
23106                                                                 }
23107                                                               else
23108                                                                 {
23109                                                                   /* 33222222222211111111110000000000
23110                                                                      10987654321098765432109876543210
23111                                                                      xx111110xx100xx0110110xxxxxxxxxx
23112                                                                      fcmle.  */
23113                                                                   return 527;
23114                                                                 }
23115                                                             }
23116                                                           else
23117                                                             {
23118                                                               if (((word >> 29) & 0x1) == 0)
23119                                                                 {
23120                                                                   /* 33222222222211111111110000000000
23121                                                                      10987654321098765432109876543210
23122                                                                      xx011110xx110xx0110110xxxxxxxxxx
23123                                                                      faddp.  */
23124                                                                   return 541;
23125                                                                 }
23126                                                               else
23127                                                                 {
23128                                                                   /* 33222222222211111111110000000000
23129                                                                      10987654321098765432109876543210
23130                                                                      xx111110xx110xx0110110xxxxxxxxxx
23131                                                                      faddp.  */
23132                                                                   return 540;
23133                                                                 }
23134                                                             }
23135                                                         }
23136                                                       else
23137                                                         {
23138                                                           if (((word >> 29) & 0x1) == 0)
23139                                                             {
23140                                                               /* 33222222222211111111110000000000
23141                                                                  10987654321098765432109876543210
23142                                                                  xx011110xx1x1xx0110110xxxxxxxxxx
23143                                                                  fcmeq.  */
23144                                                               return 498;
23145                                                             }
23146                                                           else
23147                                                             {
23148                                                               /* 33222222222211111111110000000000
23149                                                                  10987654321098765432109876543210
23150                                                                  xx111110xx1x1xx0110110xxxxxxxxxx
23151                                                                  fcmle.  */
23152                                                               return 528;
23153                                                             }
23154                                                         }
23155                                                     }
23156                                                   else
23157                                                     {
23158                                                       if (((word >> 19) & 0x1) == 0)
23159                                                         {
23160                                                           if (((word >> 23) & 0x1) == 0)
23161                                                             {
23162                                                               if (((word >> 29) & 0x1) == 0)
23163                                                                 {
23164                                                                   /* 33222222222211111111110000000000
23165                                                                      10987654321098765432109876543210
23166                                                                      xx0111100x1x0xx1110110xxxxxxxxxx
23167                                                                      scvtf.  */
23168                                                                   return 493;
23169                                                                 }
23170                                                               else
23171                                                                 {
23172                                                                   /* 33222222222211111111110000000000
23173                                                                      10987654321098765432109876543210
23174                                                                      xx1111100x1x0xx1110110xxxxxxxxxx
23175                                                                      ucvtf.  */
23176                                                                   return 523;
23177                                                                 }
23178                                                             }
23179                                                           else
23180                                                             {
23181                                                               if (((word >> 29) & 0x1) == 0)
23182                                                                 {
23183                                                                   /* 33222222222211111111110000000000
23184                                                                      10987654321098765432109876543210
23185                                                                      xx0111101x1x0xx1110110xxxxxxxxxx
23186                                                                      frecpe.  */
23187                                                                   return 505;
23188                                                                 }
23189                                                               else
23190                                                                 {
23191                                                                   /* 33222222222211111111110000000000
23192                                                                      10987654321098765432109876543210
23193                                                                      xx1111101x1x0xx1110110xxxxxxxxxx
23194                                                                      frsqrte.  */
23195                                                                   return 533;
23196                                                                 }
23197                                                             }
23198                                                         }
23199                                                       else
23200                                                         {
23201                                                           if (((word >> 23) & 0x1) == 0)
23202                                                             {
23203                                                               if (((word >> 29) & 0x1) == 0)
23204                                                                 {
23205                                                                   /* 33222222222211111111110000000000
23206                                                                      10987654321098765432109876543210
23207                                                                      xx0111100x1x1xx1110110xxxxxxxxxx
23208                                                                      scvtf.  */
23209                                                                   return 494;
23210                                                                 }
23211                                                               else
23212                                                                 {
23213                                                                   /* 33222222222211111111110000000000
23214                                                                      10987654321098765432109876543210
23215                                                                      xx1111100x1x1xx1110110xxxxxxxxxx
23216                                                                      ucvtf.  */
23217                                                                   return 524;
23218                                                                 }
23219                                                             }
23220                                                           else
23221                                                             {
23222                                                               if (((word >> 29) & 0x1) == 0)
23223                                                                 {
23224                                                                   /* 33222222222211111111110000000000
23225                                                                      10987654321098765432109876543210
23226                                                                      xx0111101x1x1xx1110110xxxxxxxxxx
23227                                                                      frecpe.  */
23228                                                                   return 506;
23229                                                                 }
23230                                                               else
23231                                                                 {
23232                                                                   /* 33222222222211111111110000000000
23233                                                                      10987654321098765432109876543210
23234                                                                      xx1111101x1x1xx1110110xxxxxxxxxx
23235                                                                      frsqrte.  */
23236                                                                   return 534;
23237                                                                 }
23238                                                             }
23239                                                         }
23240                                                     }
23241                                                 }
23242                                             }
23243                                         }
23244                                       else
23245                                         {
23246                                           if (((word >> 14) & 0x1) == 0)
23247                                             {
23248                                               if (((word >> 15) & 0x1) == 0)
23249                                                 {
23250                                                   if (((word >> 29) & 0x1) == 0)
23251                                                     {
23252                                                       if (((word >> 30) & 0x1) == 0)
23253                                                         {
23254                                                           /* 33222222222211111111110000000000
23255                                                              10987654321098765432109876543210
23256                                                              x0011110xx1xxxxx001110xxxxxxxxxx
23257                                                              fsub.  */
23258                                                           return 846;
23259                                                         }
23260                                                       else
23261                                                         {
23262                                                           /* 33222222222211111111110000000000
23263                                                              10987654321098765432109876543210
23264                                                              x1011110xx1xxxxx001110xxxxxxxxxx
23265                                                              suqadd.  */
23266                                                           return 480;
23267                                                         }
23268                                                     }
23269                                                   else
23270                                                     {
23271                                                       /* 33222222222211111111110000000000
23272                                                          10987654321098765432109876543210
23273                                                          xx111110xx1xxxxx001110xxxxxxxxxx
23274                                                          usqadd.  */
23275                                                       return 509;
23276                                                     }
23277                                                 }
23278                                               else
23279                                                 {
23280                                                   if (((word >> 16) & 0x1) == 0)
23281                                                     {
23282                                                       if (((word >> 29) & 0x1) == 0)
23283                                                         {
23284                                                           /* 33222222222211111111110000000000
23285                                                              10987654321098765432109876543210
23286                                                              xx011110xx1xxxx0101110xxxxxxxxxx
23287                                                              abs.  */
23288                                                           return 485;
23289                                                         }
23290                                                       else
23291                                                         {
23292                                                           /* 33222222222211111111110000000000
23293                                                              10987654321098765432109876543210
23294                                                              xx111110xx1xxxx0101110xxxxxxxxxx
23295                                                              neg.  */
23296                                                           return 513;
23297                                                         }
23298                                                     }
23299                                                   else
23300                                                     {
23301                                                       if (((word >> 19) & 0x1) == 0)
23302                                                         {
23303                                                           if (((word >> 20) & 0x1) == 0)
23304                                                             {
23305                                                               if (((word >> 23) & 0x1) == 0)
23306                                                                 {
23307                                                                   if (((word >> 29) & 0x1) == 0)
23308                                                                     {
23309                                                                       /* 33222222222211111111110000000000
23310                                                                          10987654321098765432109876543210
23311                                                                          xx0111100x100xx1101110xxxxxxxxxx
23312                                                                          fcvtms.  */
23313                                                                       return 489;
23314                                                                     }
23315                                                                   else
23316                                                                     {
23317                                                                       /* 33222222222211111111110000000000
23318                                                                          10987654321098765432109876543210
23319                                                                          xx1111100x100xx1101110xxxxxxxxxx
23320                                                                          fcvtmu.  */
23321                                                                       return 519;
23322                                                                     }
23323                                                                 }
23324                                                               else
23325                                                                 {
23326                                                                   if (((word >> 29) & 0x1) == 0)
23327                                                                     {
23328                                                                       /* 33222222222211111111110000000000
23329                                                                          10987654321098765432109876543210
23330                                                                          xx0111101x100xx1101110xxxxxxxxxx
23331                                                                          fcvtzs.  */
23332                                                                       return 503;
23333                                                                     }
23334                                                                   else
23335                                                                     {
23336                                                                       /* 33222222222211111111110000000000
23337                                                                          10987654321098765432109876543210
23338                                                                          xx1111101x100xx1101110xxxxxxxxxx
23339                                                                          fcvtzu.  */
23340                                                                       return 531;
23341                                                                     }
23342                                                                 }
23343                                                             }
23344                                                           else
23345                                                             {
23346                                                               /* 33222222222211111111110000000000
23347                                                                  10987654321098765432109876543210
23348                                                                  xxx11110xx110xx1101110xxxxxxxxxx
23349                                                                  addp.  */
23350                                                               return 537;
23351                                                             }
23352                                                         }
23353                                                       else
23354                                                         {
23355                                                           if (((word >> 23) & 0x1) == 0)
23356                                                             {
23357                                                               if (((word >> 29) & 0x1) == 0)
23358                                                                 {
23359                                                                   /* 33222222222211111111110000000000
23360                                                                      10987654321098765432109876543210
23361                                                                      xx0111100x1x1xx1101110xxxxxxxxxx
23362                                                                      fcvtms.  */
23363                                                                   return 490;
23364                                                                 }
23365                                                               else
23366                                                                 {
23367                                                                   /* 33222222222211111111110000000000
23368                                                                      10987654321098765432109876543210
23369                                                                      xx1111100x1x1xx1101110xxxxxxxxxx
23370                                                                      fcvtmu.  */
23371                                                                   return 520;
23372                                                                 }
23373                                                             }
23374                                                           else
23375                                                             {
23376                                                               if (((word >> 29) & 0x1) == 0)
23377                                                                 {
23378                                                                   /* 33222222222211111111110000000000
23379                                                                      10987654321098765432109876543210
23380                                                                      xx0111101x1x1xx1101110xxxxxxxxxx
23381                                                                      fcvtzs.  */
23382                                                                   return 504;
23383                                                                 }
23384                                                               else
23385                                                                 {
23386                                                                   /* 33222222222211111111110000000000
23387                                                                      10987654321098765432109876543210
23388                                                                      xx1111101x1x1xx1101110xxxxxxxxxx
23389                                                                      fcvtzu.  */
23390                                                                   return 532;
23391                                                                 }
23392                                                             }
23393                                                         }
23394                                                     }
23395                                                 }
23396                                             }
23397                                           else
23398                                             {
23399                                               if (((word >> 15) & 0x1) == 0)
23400                                                 {
23401                                                   if (((word >> 29) & 0x1) == 0)
23402                                                     {
23403                                                       if (((word >> 30) & 0x1) == 0)
23404                                                         {
23405                                                           /* 33222222222211111111110000000000
23406                                                              10987654321098765432109876543210
23407                                                              x0011110xx1xxxxx011110xxxxxxxxxx
23408                                                              fminnm.  */
23409                                                           return 854;
23410                                                         }
23411                                                       else
23412                                                         {
23413                                                           /* 33222222222211111111110000000000
23414                                                              10987654321098765432109876543210
23415                                                              x1011110xx1xxxxx011110xxxxxxxxxx
23416                                                              sqabs.  */
23417                                                           return 481;
23418                                                         }
23419                                                     }
23420                                                   else
23421                                                     {
23422                                                       /* 33222222222211111111110000000000
23423                                                          10987654321098765432109876543210
23424                                                          xx111110xx1xxxxx011110xxxxxxxxxx
23425                                                          sqneg.  */
23426                                                       return 510;
23427                                                     }
23428                                                 }
23429                                               else
23430                                                 {
23431                                                   if (((word >> 16) & 0x1) == 0)
23432                                                     {
23433                                                       if (((word >> 23) & 0x1) == 0)
23434                                                         {
23435                                                           if (((word >> 29) & 0x1) == 0)
23436                                                             {
23437                                                               /* 33222222222211111111110000000000
23438                                                                  10987654321098765432109876543210
23439                                                                  xx0111100x1xxxx0111110xxxxxxxxxx
23440                                                                  fmaxp.  */
23441                                                               return 543;
23442                                                             }
23443                                                           else
23444                                                             {
23445                                                               /* 33222222222211111111110000000000
23446                                                                  10987654321098765432109876543210
23447                                                                  xx1111100x1xxxx0111110xxxxxxxxxx
23448                                                                  fmaxp.  */
23449                                                               return 542;
23450                                                             }
23451                                                         }
23452                                                       else
23453                                                         {
23454                                                           if (((word >> 29) & 0x1) == 0)
23455                                                             {
23456                                                               /* 33222222222211111111110000000000
23457                                                                  10987654321098765432109876543210
23458                                                                  xx0111101x1xxxx0111110xxxxxxxxxx
23459                                                                  fminp.  */
23460                                                               return 547;
23461                                                             }
23462                                                           else
23463                                                             {
23464                                                               /* 33222222222211111111110000000000
23465                                                                  10987654321098765432109876543210
23466                                                                  xx1111101x1xxxx0111110xxxxxxxxxx
23467                                                                  fminp.  */
23468                                                               return 546;
23469                                                             }
23470                                                         }
23471                                                     }
23472                                                   else
23473                                                     {
23474                                                       if (((word >> 19) & 0x1) == 0)
23475                                                         {
23476                                                           /* 33222222222211111111110000000000
23477                                                              10987654321098765432109876543210
23478                                                              xxx11110xx1x0xx1111110xxxxxxxxxx
23479                                                              frecpx.  */
23480                                                           return 507;
23481                                                         }
23482                                                       else
23483                                                         {
23484                                                           /* 33222222222211111111110000000000
23485                                                              10987654321098765432109876543210
23486                                                              xxx11110xx1x1xx1111110xxxxxxxxxx
23487                                                              frecpx.  */
23488                                                           return 508;
23489                                                         }
23490                                                     }
23491                                                 }
23492                                             }
23493                                         }
23494                                     }
23495                                 }
23496                             }
23497                           else
23498                             {
23499                               if (((word >> 11) & 0x1) == 0)
23500                                 {
23501                                   if (((word >> 29) & 0x1) == 0)
23502                                     {
23503                                       if (((word >> 30) & 0x1) == 0)
23504                                         {
23505                                           if (((word >> 4) & 0x1) == 0)
23506                                             {
23507                                               /* 33222222222211111111110000000000
23508                                                  10987654321098765432109876543210
23509                                                  x0011110xx1xxxxxxxxx01xxxxx0xxxx
23510                                                  fccmp.  */
23511                                               return 799;
23512                                             }
23513                                           else
23514                                             {
23515                                               /* 33222222222211111111110000000000
23516                                                  10987654321098765432109876543210
23517                                                  x0011110xx1xxxxxxxxx01xxxxx1xxxx
23518                                                  fccmpe.  */
23519                                               return 801;
23520                                             }
23521                                         }
23522                                       else
23523                                         {
23524                                           if (((word >> 12) & 0x1) == 0)
23525                                             {
23526                                               if (((word >> 13) & 0x1) == 0)
23527                                                 {
23528                                                   if (((word >> 14) & 0x1) == 0)
23529                                                     {
23530                                                       /* 33222222222211111111110000000000
23531                                                          10987654321098765432109876543210
23532                                                          x1011110xx1xxxxxx00001xxxxxxxxxx
23533                                                          add.  */
23534                                                       return 565;
23535                                                     }
23536                                                   else
23537                                                     {
23538                                                       /* 33222222222211111111110000000000
23539                                                          10987654321098765432109876543210
23540                                                          x1011110xx1xxxxxx10001xxxxxxxxxx
23541                                                          sshl.  */
23542                                                       return 563;
23543                                                     }
23544                                                 }
23545                                               else
23546                                                 {
23547                                                   /* 33222222222211111111110000000000
23548                                                      10987654321098765432109876543210
23549                                                      x1011110xx1xxxxxxx1001xxxxxxxxxx
23550                                                      fcmeq.  */
23551                                                   return 555;
23552                                                 }
23553                                             }
23554                                           else
23555                                             {
23556                                               if (((word >> 13) & 0x1) == 0)
23557                                                 {
23558                                                   /* 33222222222211111111110000000000
23559                                                      10987654321098765432109876543210
23560                                                      x1011110xx1xxxxxxx0101xxxxxxxxxx
23561                                                      srshl.  */
23562                                                   return 564;
23563                                                 }
23564                                               else
23565                                                 {
23566                                                   if (((word >> 15) & 0x1) == 0)
23567                                                     {
23568                                                       /* 33222222222211111111110000000000
23569                                                          10987654321098765432109876543210
23570                                                          x1011110xx1xxxxx0x1101xxxxxxxxxx
23571                                                          cmgt.  */
23572                                                       return 561;
23573                                                     }
23574                                                   else
23575                                                     {
23576                                                       /* 33222222222211111111110000000000
23577                                                          10987654321098765432109876543210
23578                                                          x1011110xx1xxxxx1x1101xxxxxxxxxx
23579                                                          sqdmulh.  */
23580                                                       return 552;
23581                                                     }
23582                                                 }
23583                                             }
23584                                         }
23585                                     }
23586                                   else
23587                                     {
23588                                       if (((word >> 12) & 0x1) == 0)
23589                                         {
23590                                           if (((word >> 13) & 0x1) == 0)
23591                                             {
23592                                               if (((word >> 14) & 0x1) == 0)
23593                                                 {
23594                                                   /* 33222222222211111111110000000000
23595                                                      10987654321098765432109876543210
23596                                                      xx111110xx1xxxxxx00001xxxxxxxxxx
23597                                                      sub.  */
23598                                                   return 586;
23599                                                 }
23600                                               else
23601                                                 {
23602                                                   /* 33222222222211111111110000000000
23603                                                      10987654321098765432109876543210
23604                                                      xx111110xx1xxxxxx10001xxxxxxxxxx
23605                                                      ushl.  */
23606                                                   return 584;
23607                                                 }
23608                                             }
23609                                           else
23610                                             {
23611                                               if (((word >> 23) & 0x1) == 0)
23612                                                 {
23613                                                   /* 33222222222211111111110000000000
23614                                                      10987654321098765432109876543210
23615                                                      xx1111100x1xxxxxxx1001xxxxxxxxxx
23616                                                      fcmge.  */
23617                                                   return 572;
23618                                                 }
23619                                               else
23620                                                 {
23621                                                   /* 33222222222211111111110000000000
23622                                                      10987654321098765432109876543210
23623                                                      xx1111101x1xxxxxxx1001xxxxxxxxxx
23624                                                      fcmgt.  */
23625                                                   return 578;
23626                                                 }
23627                                             }
23628                                         }
23629                                       else
23630                                         {
23631                                           if (((word >> 13) & 0x1) == 0)
23632                                             {
23633                                               if (((word >> 15) & 0x1) == 0)
23634                                                 {
23635                                                   /* 33222222222211111111110000000000
23636                                                      10987654321098765432109876543210
23637                                                      xx111110xx1xxxxx0x0101xxxxxxxxxx
23638                                                      urshl.  */
23639                                                   return 585;
23640                                                 }
23641                                               else
23642                                                 {
23643                                                   /* 33222222222211111111110000000000
23644                                                      10987654321098765432109876543210
23645                                                      xx111110xx1xxxxx1x0101xxxxxxxxxx
23646                                                      fabd.  */
23647                                                   return 576;
23648                                                 }
23649                                             }
23650                                           else
23651                                             {
23652                                               if (((word >> 15) & 0x1) == 0)
23653                                                 {
23654                                                   /* 33222222222211111111110000000000
23655                                                      10987654321098765432109876543210
23656                                                      xx111110xx1xxxxx0x1101xxxxxxxxxx
23657                                                      cmhi.  */
23658                                                   return 582;
23659                                                 }
23660                                               else
23661                                                 {
23662                                                   /* 33222222222211111111110000000000
23663                                                      10987654321098765432109876543210
23664                                                      xx111110xx1xxxxx1x1101xxxxxxxxxx
23665                                                      sqrdmulh.  */
23666                                                   return 571;
23667                                                 }
23668                                             }
23669                                         }
23670                                     }
23671                                 }
23672                               else
23673                                 {
23674                                   if (((word >> 29) & 0x1) == 0)
23675                                     {
23676                                       if (((word >> 30) & 0x1) == 0)
23677                                         {
23678                                           /* 33222222222211111111110000000000
23679                                              10987654321098765432109876543210
23680                                              x0011110xx1xxxxxxxxx11xxxxxxxxxx
23681                                              fcsel.  */
23682                                           return 868;
23683                                         }
23684                                       else
23685                                         {
23686                                           if (((word >> 12) & 0x1) == 0)
23687                                             {
23688                                               if (((word >> 13) & 0x1) == 0)
23689                                                 {
23690                                                   if (((word >> 14) & 0x1) == 0)
23691                                                     {
23692                                                       if (((word >> 15) & 0x1) == 0)
23693                                                         {
23694                                                           /* 33222222222211111111110000000000
23695                                                              10987654321098765432109876543210
23696                                                              x1011110xx1xxxxx000011xxxxxxxxxx
23697                                                              sqadd.  */
23698                                                           return 548;
23699                                                         }
23700                                                       else
23701                                                         {
23702                                                           /* 33222222222211111111110000000000
23703                                                              10987654321098765432109876543210
23704                                                              x1011110xx1xxxxx100011xxxxxxxxxx
23705                                                              cmtst.  */
23706                                                           return 566;
23707                                                         }
23708                                                     }
23709                                                   else
23710                                                     {
23711                                                       /* 33222222222211111111110000000000
23712                                                          10987654321098765432109876543210
23713                                                          x1011110xx1xxxxxx10011xxxxxxxxxx
23714                                                          sqshl.  */
23715                                                       return 550;
23716                                                     }
23717                                                 }
23718                                               else
23719                                                 {
23720                                                   /* 33222222222211111111110000000000
23721                                                      10987654321098765432109876543210
23722                                                      x1011110xx1xxxxxxx1011xxxxxxxxxx
23723                                                      sqsub.  */
23724                                                   return 549;
23725                                                 }
23726                                             }
23727                                           else
23728                                             {
23729                                               if (((word >> 13) & 0x1) == 0)
23730                                                 {
23731                                                   if (((word >> 15) & 0x1) == 0)
23732                                                     {
23733                                                       /* 33222222222211111111110000000000
23734                                                          10987654321098765432109876543210
23735                                                          x1011110xx1xxxxx0x0111xxxxxxxxxx
23736                                                          sqrshl.  */
23737                                                       return 551;
23738                                                     }
23739                                                   else
23740                                                     {
23741                                                       /* 33222222222211111111110000000000
23742                                                          10987654321098765432109876543210
23743                                                          x1011110xx1xxxxx1x0111xxxxxxxxxx
23744                                                          fmulx.  */
23745                                                       return 553;
23746                                                     }
23747                                                 }
23748                                               else
23749                                                 {
23750                                                   if (((word >> 14) & 0x1) == 0)
23751                                                     {
23752                                                       /* 33222222222211111111110000000000
23753                                                          10987654321098765432109876543210
23754                                                          x1011110xx1xxxxxx01111xxxxxxxxxx
23755                                                          cmge.  */
23756                                                       return 562;
23757                                                     }
23758                                                   else
23759                                                     {
23760                                                       if (((word >> 23) & 0x1) == 0)
23761                                                         {
23762                                                           /* 33222222222211111111110000000000
23763                                                              10987654321098765432109876543210
23764                                                              x10111100x1xxxxxx11111xxxxxxxxxx
23765                                                              frecps.  */
23766                                                           return 557;
23767                                                         }
23768                                                       else
23769                                                         {
23770                                                           /* 33222222222211111111110000000000
23771                                                              10987654321098765432109876543210
23772                                                              x10111101x1xxxxxx11111xxxxxxxxxx
23773                                                              frsqrts.  */
23774                                                           return 559;
23775                                                         }
23776                                                     }
23777                                                 }
23778                                             }
23779                                         }
23780                                     }
23781                                   else
23782                                     {
23783                                       if (((word >> 12) & 0x1) == 0)
23784                                         {
23785                                           if (((word >> 13) & 0x1) == 0)
23786                                             {
23787                                               if (((word >> 14) & 0x1) == 0)
23788                                                 {
23789                                                   if (((word >> 15) & 0x1) == 0)
23790                                                     {
23791                                                       /* 33222222222211111111110000000000
23792                                                          10987654321098765432109876543210
23793                                                          xx111110xx1xxxxx000011xxxxxxxxxx
23794                                                          uqadd.  */
23795                                                       return 567;
23796                                                     }
23797                                                   else
23798                                                     {
23799                                                       /* 33222222222211111111110000000000
23800                                                          10987654321098765432109876543210
23801                                                          xx111110xx1xxxxx100011xxxxxxxxxx
23802                                                          cmeq.  */
23803                                                       return 587;
23804                                                     }
23805                                                 }
23806                                               else
23807                                                 {
23808                                                   /* 33222222222211111111110000000000
23809                                                      10987654321098765432109876543210
23810                                                      xx111110xx1xxxxxx10011xxxxxxxxxx
23811                                                      uqshl.  */
23812                                                   return 569;
23813                                                 }
23814                                             }
23815                                           else
23816                                             {
23817                                               if (((word >> 14) & 0x1) == 0)
23818                                                 {
23819                                                   /* 33222222222211111111110000000000
23820                                                      10987654321098765432109876543210
23821                                                      xx111110xx1xxxxxx01011xxxxxxxxxx
23822                                                      uqsub.  */
23823                                                   return 568;
23824                                                 }
23825                                               else
23826                                                 {
23827                                                   if (((word >> 23) & 0x1) == 0)
23828                                                     {
23829                                                       /* 33222222222211111111110000000000
23830                                                          10987654321098765432109876543210
23831                                                          xx1111100x1xxxxxx11011xxxxxxxxxx
23832                                                          facge.  */
23833                                                       return 574;
23834                                                     }
23835                                                   else
23836                                                     {
23837                                                       /* 33222222222211111111110000000000
23838                                                          10987654321098765432109876543210
23839                                                          xx1111101x1xxxxxx11011xxxxxxxxxx
23840                                                          facgt.  */
23841                                                       return 580;
23842                                                     }
23843                                                 }
23844                                             }
23845                                         }
23846                                       else
23847                                         {
23848                                           if (((word >> 13) & 0x1) == 0)
23849                                             {
23850                                               /* 33222222222211111111110000000000
23851                                                  10987654321098765432109876543210
23852                                                  xx111110xx1xxxxxxx0111xxxxxxxxxx
23853                                                  uqrshl.  */
23854                                               return 570;
23855                                             }
23856                                           else
23857                                             {
23858                                               /* 33222222222211111111110000000000
23859                                                  10987654321098765432109876543210
23860                                                  xx111110xx1xxxxxxx1111xxxxxxxxxx
23861                                                  cmhs.  */
23862                                               return 583;
23863                                             }
23864                                         }
23865                                     }
23866                                 }
23867                             }
23868                         }
23869                     }
23870                 }
23871               else
23872                 {
23873                   if (((word >> 15) & 0x1) == 0)
23874                     {
23875                       if (((word >> 28) & 0x1) == 0)
23876                         {
23877                           if (((word >> 10) & 0x1) == 0)
23878                             {
23879                               if (((word >> 12) & 0x1) == 0)
23880                                 {
23881                                   if (((word >> 13) & 0x1) == 0)
23882                                     {
23883                                       if (((word >> 14) & 0x1) == 0)
23884                                         {
23885                                           if (((word >> 29) & 0x1) == 0)
23886                                             {
23887                                               if (((word >> 30) & 0x1) == 0)
23888                                                 {
23889                                                   /* 33222222222211111111110000000000
23890                                                      10987654321098765432109876543210
23891                                                      x0001111xxxxxxxx0000x0xxxxxxxxxx
23892                                                      fmlal.  */
23893                                                   return 2444;
23894                                                 }
23895                                               else
23896                                                 {
23897                                                   /* 33222222222211111111110000000000
23898                                                      10987654321098765432109876543210
23899                                                      x1001111xxxxxxxx0000x0xxxxxxxxxx
23900                                                      fmlal.  */
23901                                                   return 2448;
23902                                                 }
23903                                             }
23904                                           else
23905                                             {
23906                                               /* 33222222222211111111110000000000
23907                                                  10987654321098765432109876543210
23908                                                  xx101111xxxxxxxx0000x0xxxxxxxxxx
23909                                                  mla.  */
23910                                               return 119;
23911                                             }
23912                                         }
23913                                       else
23914                                         {
23915                                           if (((word >> 29) & 0x1) == 0)
23916                                             {
23917                                               if (((word >> 30) & 0x1) == 0)
23918                                                 {
23919                                                   /* 33222222222211111111110000000000
23920                                                      10987654321098765432109876543210
23921                                                      x0001111xxxxxxxx0100x0xxxxxxxxxx
23922                                                      fmlsl.  */
23923                                                   return 2445;
23924                                                 }
23925                                               else
23926                                                 {
23927                                                   /* 33222222222211111111110000000000
23928                                                      10987654321098765432109876543210
23929                                                      x1001111xxxxxxxx0100x0xxxxxxxxxx
23930                                                      fmlsl.  */
23931                                                   return 2449;
23932                                                 }
23933                                             }
23934                                           else
23935                                             {
23936                                               /* 33222222222211111111110000000000
23937                                                  10987654321098765432109876543210
23938                                                  xx101111xxxxxxxx0100x0xxxxxxxxxx
23939                                                  mls.  */
23940                                               return 122;
23941                                             }
23942                                         }
23943                                     }
23944                                   else
23945                                     {
23946                                       if (((word >> 14) & 0x1) == 0)
23947                                         {
23948                                           if (((word >> 29) & 0x1) == 0)
23949                                             {
23950                                               if (((word >> 30) & 0x1) == 0)
23951                                                 {
23952                                                   /* 33222222222211111111110000000000
23953                                                      10987654321098765432109876543210
23954                                                      x0001111xxxxxxxx0010x0xxxxxxxxxx
23955                                                      smlal.  */
23956                                                   return 98;
23957                                                 }
23958                                               else
23959                                                 {
23960                                                   /* 33222222222211111111110000000000
23961                                                      10987654321098765432109876543210
23962                                                      x1001111xxxxxxxx0010x0xxxxxxxxxx
23963                                                      smlal2.  */
23964                                                   return 99;
23965                                                 }
23966                                             }
23967                                           else
23968                                             {
23969                                               if (((word >> 30) & 0x1) == 0)
23970                                                 {
23971                                                   /* 33222222222211111111110000000000
23972                                                      10987654321098765432109876543210
23973                                                      x0101111xxxxxxxx0010x0xxxxxxxxxx
23974                                                      umlal.  */
23975                                                   return 120;
23976                                                 }
23977                                               else
23978                                                 {
23979                                                   /* 33222222222211111111110000000000
23980                                                      10987654321098765432109876543210
23981                                                      x1101111xxxxxxxx0010x0xxxxxxxxxx
23982                                                      umlal2.  */
23983                                                   return 121;
23984                                                 }
23985                                             }
23986                                         }
23987                                       else
23988                                         {
23989                                           if (((word >> 29) & 0x1) == 0)
23990                                             {
23991                                               if (((word >> 30) & 0x1) == 0)
23992                                                 {
23993                                                   /* 33222222222211111111110000000000
23994                                                      10987654321098765432109876543210
23995                                                      x0001111xxxxxxxx0110x0xxxxxxxxxx
23996                                                      smlsl.  */
23997                                                   return 102;
23998                                                 }
23999                                               else
24000                                                 {
24001                                                   /* 33222222222211111111110000000000
24002                                                      10987654321098765432109876543210
24003                                                      x1001111xxxxxxxx0110x0xxxxxxxxxx
24004                                                      smlsl2.  */
24005                                                   return 103;
24006                                                 }
24007                                             }
24008                                           else
24009                                             {
24010                                               if (((word >> 30) & 0x1) == 0)
24011                                                 {
24012                                                   /* 33222222222211111111110000000000
24013                                                      10987654321098765432109876543210
24014                                                      x0101111xxxxxxxx0110x0xxxxxxxxxx
24015                                                      umlsl.  */
24016                                                   return 123;
24017                                                 }
24018                                               else
24019                                                 {
24020                                                   /* 33222222222211111111110000000000
24021                                                      10987654321098765432109876543210
24022                                                      x1101111xxxxxxxx0110x0xxxxxxxxxx
24023                                                      umlsl2.  */
24024                                                   return 124;
24025                                                 }
24026                                             }
24027                                         }
24028                                     }
24029                                 }
24030                               else
24031                                 {
24032                                   if (((word >> 29) & 0x1) == 0)
24033                                     {
24034                                       if (((word >> 13) & 0x1) == 0)
24035                                         {
24036                                           if (((word >> 14) & 0x1) == 0)
24037                                             {
24038                                               if (((word >> 23) & 0x1) == 0)
24039                                                 {
24040                                                   /* 33222222222211111111110000000000
24041                                                      10987654321098765432109876543210
24042                                                      xx0011110xxxxxxx0001x0xxxxxxxxxx
24043                                                      fmla.  */
24044                                                   return 114;
24045                                                 }
24046                                               else
24047                                                 {
24048                                                   /* 33222222222211111111110000000000
24049                                                      10987654321098765432109876543210
24050                                                      xx0011111xxxxxxx0001x0xxxxxxxxxx
24051                                                      fmla.  */
24052                                                   return 113;
24053                                                 }
24054                                             }
24055                                           else
24056                                             {
24057                                               if (((word >> 23) & 0x1) == 0)
24058                                                 {
24059                                                   /* 33222222222211111111110000000000
24060                                                      10987654321098765432109876543210
24061                                                      xx0011110xxxxxxx0101x0xxxxxxxxxx
24062                                                      fmls.  */
24063                                                   return 116;
24064                                                 }
24065                                               else
24066                                                 {
24067                                                   /* 33222222222211111111110000000000
24068                                                      10987654321098765432109876543210
24069                                                      xx0011111xxxxxxx0101x0xxxxxxxxxx
24070                                                      fmls.  */
24071                                                   return 115;
24072                                                 }
24073                                             }
24074                                         }
24075                                       else
24076                                         {
24077                                           if (((word >> 14) & 0x1) == 0)
24078                                             {
24079                                               if (((word >> 30) & 0x1) == 0)
24080                                                 {
24081                                                   /* 33222222222211111111110000000000
24082                                                      10987654321098765432109876543210
24083                                                      x0001111xxxxxxxx0011x0xxxxxxxxxx
24084                                                      sqdmlal.  */
24085                                                   return 100;
24086                                                 }
24087                                               else
24088                                                 {
24089                                                   /* 33222222222211111111110000000000
24090                                                      10987654321098765432109876543210
24091                                                      x1001111xxxxxxxx0011x0xxxxxxxxxx
24092                                                      sqdmlal2.  */
24093                                                   return 101;
24094                                                 }
24095                                             }
24096                                           else
24097                                             {
24098                                               if (((word >> 30) & 0x1) == 0)
24099                                                 {
24100                                                   /* 33222222222211111111110000000000
24101                                                      10987654321098765432109876543210
24102                                                      x0001111xxxxxxxx0111x0xxxxxxxxxx
24103                                                      sqdmlsl.  */
24104                                                   return 104;
24105                                                 }
24106                                               else
24107                                                 {
24108                                                   /* 33222222222211111111110000000000
24109                                                      10987654321098765432109876543210
24110                                                      x1001111xxxxxxxx0111x0xxxxxxxxxx
24111                                                      sqdmlsl2.  */
24112                                                   return 105;
24113                                                 }
24114                                             }
24115                                         }
24116                                     }
24117                                   else
24118                                     {
24119                                       /* 33222222222211111111110000000000
24120                                          10987654321098765432109876543210
24121                                          xx101111xxxxxxxx0xx1x0xxxxxxxxxx
24122                                          fcmla.  */
24123                                       return 131;
24124                                     }
24125                                 }
24126                             }
24127                           else
24128                             {
24129                               if (((word >> 12) & 0x1) == 0)
24130                                 {
24131                                   if (((word >> 29) & 0x1) == 0)
24132                                     {
24133                                       /* 33222222222211111111110000000000
24134                                          10987654321098765432109876543210
24135                                          xx001111xxxxxxxx0xx0x1xxxxxxxxxx
24136                                          movi.  */
24137                                       return 133;
24138                                     }
24139                                   else
24140                                     {
24141                                       /* 33222222222211111111110000000000
24142                                          10987654321098765432109876543210
24143                                          xx101111xxxxxxxx0xx0x1xxxxxxxxxx
24144                                          mvni.  */
24145                                       return 141;
24146                                     }
24147                                 }
24148                               else
24149                                 {
24150                                   if (((word >> 29) & 0x1) == 0)
24151                                     {
24152                                       /* 33222222222211111111110000000000
24153                                          10987654321098765432109876543210
24154                                          xx001111xxxxxxxx0xx1x1xxxxxxxxxx
24155                                          orr.  */
24156                                       return 134;
24157                                     }
24158                                   else
24159                                     {
24160                                       /* 33222222222211111111110000000000
24161                                          10987654321098765432109876543210
24162                                          xx101111xxxxxxxx0xx1x1xxxxxxxxxx
24163                                          bic.  */
24164                                       return 142;
24165                                     }
24166                                 }
24167                             }
24168                         }
24169                       else
24170                         {
24171                           if (((word >> 29) & 0x1) == 0)
24172                             {
24173                               if (((word >> 30) & 0x1) == 0)
24174                                 {
24175                                   if (((word >> 21) & 0x1) == 0)
24176                                     {
24177                                       /* 33222222222211111111110000000000
24178                                          10987654321098765432109876543210
24179                                          x0011111xx0xxxxx0xxxxxxxxxxxxxxx
24180                                          fmadd.  */
24181                                       return 858;
24182                                     }
24183                                   else
24184                                     {
24185                                       /* 33222222222211111111110000000000
24186                                          10987654321098765432109876543210
24187                                          x0011111xx1xxxxx0xxxxxxxxxxxxxxx
24188                                          fnmadd.  */
24189                                       return 862;
24190                                     }
24191                                 }
24192                               else
24193                                 {
24194                                   if (((word >> 10) & 0x1) == 0)
24195                                     {
24196                                       if (((word >> 13) & 0x1) == 0)
24197                                         {
24198                                           if (((word >> 14) & 0x1) == 0)
24199                                             {
24200                                               if (((word >> 23) & 0x1) == 0)
24201                                                 {
24202                                                   /* 33222222222211111111110000000000
24203                                                      10987654321098765432109876543210
24204                                                      x10111110xxxxxxx000xx0xxxxxxxxxx
24205                                                      fmla.  */
24206                                                   return 431;
24207                                                 }
24208                                               else
24209                                                 {
24210                                                   /* 33222222222211111111110000000000
24211                                                      10987654321098765432109876543210
24212                                                      x10111111xxxxxxx000xx0xxxxxxxxxx
24213                                                      fmla.  */
24214                                                   return 430;
24215                                                 }
24216                                             }
24217                                           else
24218                                             {
24219                                               if (((word >> 23) & 0x1) == 0)
24220                                                 {
24221                                                   /* 33222222222211111111110000000000
24222                                                      10987654321098765432109876543210
24223                                                      x10111110xxxxxxx010xx0xxxxxxxxxx
24224                                                      fmls.  */
24225                                                   return 433;
24226                                                 }
24227                                               else
24228                                                 {
24229                                                   /* 33222222222211111111110000000000
24230                                                      10987654321098765432109876543210
24231                                                      x10111111xxxxxxx010xx0xxxxxxxxxx
24232                                                      fmls.  */
24233                                                   return 432;
24234                                                 }
24235                                             }
24236                                         }
24237                                       else
24238                                         {
24239                                           if (((word >> 14) & 0x1) == 0)
24240                                             {
24241                                               /* 33222222222211111111110000000000
24242                                                  10987654321098765432109876543210
24243                                                  x1011111xxxxxxxx001xx0xxxxxxxxxx
24244                                                  sqdmlal.  */
24245                                               return 425;
24246                                             }
24247                                           else
24248                                             {
24249                                               /* 33222222222211111111110000000000
24250                                                  10987654321098765432109876543210
24251                                                  x1011111xxxxxxxx011xx0xxxxxxxxxx
24252                                                  sqdmlsl.  */
24253                                               return 426;
24254                                             }
24255                                         }
24256                                     }
24257                                   else
24258                                     {
24259                                       if (((word >> 12) & 0x1) == 0)
24260                                         {
24261                                           if (((word >> 13) & 0x1) == 0)
24262                                             {
24263                                               /* 33222222222211111111110000000000
24264                                                  10987654321098765432109876543210
24265                                                  x1011111xxxxxxxx0x00x1xxxxxxxxxx
24266                                                  sshr.  */
24267                                               return 590;
24268                                             }
24269                                           else
24270                                             {
24271                                               /* 33222222222211111111110000000000
24272                                                  10987654321098765432109876543210
24273                                                  x1011111xxxxxxxx0x10x1xxxxxxxxxx
24274                                                  srshr.  */
24275                                               return 592;
24276                                             }
24277                                         }
24278                                       else
24279                                         {
24280                                           if (((word >> 13) & 0x1) == 0)
24281                                             {
24282                                               if (((word >> 14) & 0x1) == 0)
24283                                                 {
24284                                                   /* 33222222222211111111110000000000
24285                                                      10987654321098765432109876543210
24286                                                      x1011111xxxxxxxx0001x1xxxxxxxxxx
24287                                                      ssra.  */
24288                                                   return 591;
24289                                                 }
24290                                               else
24291                                                 {
24292                                                   /* 33222222222211111111110000000000
24293                                                      10987654321098765432109876543210
24294                                                      x1011111xxxxxxxx0101x1xxxxxxxxxx
24295                                                      shl.  */
24296                                                   return 594;
24297                                                 }
24298                                             }
24299                                           else
24300                                             {
24301                                               if (((word >> 14) & 0x1) == 0)
24302                                                 {
24303                                                   /* 33222222222211111111110000000000
24304                                                      10987654321098765432109876543210
24305                                                      x1011111xxxxxxxx0011x1xxxxxxxxxx
24306                                                      srsra.  */
24307                                                   return 593;
24308                                                 }
24309                                               else
24310                                                 {
24311                                                   /* 33222222222211111111110000000000
24312                                                      10987654321098765432109876543210
24313                                                      x1011111xxxxxxxx0111x1xxxxxxxxxx
24314                                                      sqshl.  */
24315                                                   return 595;
24316                                                 }
24317                                             }
24318                                         }
24319                                     }
24320                                 }
24321                             }
24322                           else
24323                             {
24324                               if (((word >> 12) & 0x1) == 0)
24325                                 {
24326                                   if (((word >> 13) & 0x1) == 0)
24327                                     {
24328                                       if (((word >> 14) & 0x1) == 0)
24329                                         {
24330                                           /* 33222222222211111111110000000000
24331                                              10987654321098765432109876543210
24332                                              xx111111xxxxxxxx0000xxxxxxxxxxxx
24333                                              ushr.  */
24334                                           return 602;
24335                                         }
24336                                       else
24337                                         {
24338                                           /* 33222222222211111111110000000000
24339                                              10987654321098765432109876543210
24340                                              xx111111xxxxxxxx0100xxxxxxxxxxxx
24341                                              sri.  */
24342                                           return 606;
24343                                         }
24344                                     }
24345                                   else
24346                                     {
24347                                       if (((word >> 14) & 0x1) == 0)
24348                                         {
24349                                           /* 33222222222211111111110000000000
24350                                              10987654321098765432109876543210
24351                                              xx111111xxxxxxxx0010xxxxxxxxxxxx
24352                                              urshr.  */
24353                                           return 604;
24354                                         }
24355                                       else
24356                                         {
24357                                           /* 33222222222211111111110000000000
24358                                              10987654321098765432109876543210
24359                                              xx111111xxxxxxxx0110xxxxxxxxxxxx
24360                                              sqshlu.  */
24361                                           return 608;
24362                                         }
24363                                     }
24364                                 }
24365                               else
24366                                 {
24367                                   if (((word >> 13) & 0x1) == 0)
24368                                     {
24369                                       if (((word >> 14) & 0x1) == 0)
24370                                         {
24371                                           /* 33222222222211111111110000000000
24372                                              10987654321098765432109876543210
24373                                              xx111111xxxxxxxx0001xxxxxxxxxxxx
24374                                              usra.  */
24375                                           return 603;
24376                                         }
24377                                       else
24378                                         {
24379                                           /* 33222222222211111111110000000000
24380                                              10987654321098765432109876543210
24381                                              xx111111xxxxxxxx0101xxxxxxxxxxxx
24382                                              sli.  */
24383                                           return 607;
24384                                         }
24385                                     }
24386                                   else
24387                                     {
24388                                       if (((word >> 14) & 0x1) == 0)
24389                                         {
24390                                           /* 33222222222211111111110000000000
24391                                              10987654321098765432109876543210
24392                                              xx111111xxxxxxxx0011xxxxxxxxxxxx
24393                                              ursra.  */
24394                                           return 605;
24395                                         }
24396                                       else
24397                                         {
24398                                           /* 33222222222211111111110000000000
24399                                              10987654321098765432109876543210
24400                                              xx111111xxxxxxxx0111xxxxxxxxxxxx
24401                                              uqshl.  */
24402                                           return 609;
24403                                         }
24404                                     }
24405                                 }
24406                             }
24407                         }
24408                     }
24409                   else
24410                     {
24411                       if (((word >> 28) & 0x1) == 0)
24412                         {
24413                           if (((word >> 10) & 0x1) == 0)
24414                             {
24415                               if (((word >> 12) & 0x1) == 0)
24416                                 {
24417                                   if (((word >> 13) & 0x1) == 0)
24418                                     {
24419                                       if (((word >> 14) & 0x1) == 0)
24420                                         {
24421                                           if (((word >> 29) & 0x1) == 0)
24422                                             {
24423                                               /* 33222222222211111111110000000000
24424                                                  10987654321098765432109876543210
24425                                                  xx001111xxxxxxxx1000x0xxxxxxxxxx
24426                                                  mul.  */
24427                                               return 106;
24428                                             }
24429                                           else
24430                                             {
24431                                               if (((word >> 30) & 0x1) == 0)
24432                                                 {
24433                                                   /* 33222222222211111111110000000000
24434                                                      10987654321098765432109876543210
24435                                                      x0101111xxxxxxxx1000x0xxxxxxxxxx
24436                                                      fmlal2.  */
24437                                                   return 2446;
24438                                                 }
24439                                               else
24440                                                 {
24441                                                   /* 33222222222211111111110000000000
24442                                                      10987654321098765432109876543210
24443                                                      x1101111xxxxxxxx1000x0xxxxxxxxxx
24444                                                      fmlal2.  */
24445                                                   return 2450;
24446                                                 }
24447                                             }
24448                                         }
24449                                       else
24450                                         {
24451                                           if (((word >> 29) & 0x1) == 0)
24452                                             {
24453                                               /* 33222222222211111111110000000000
24454                                                  10987654321098765432109876543210
24455                                                  xx001111xxxxxxxx1100x0xxxxxxxxxx
24456                                                  sqdmulh.  */
24457                                               return 111;
24458                                             }
24459                                           else
24460                                             {
24461                                               if (((word >> 30) & 0x1) == 0)
24462                                                 {
24463                                                   /* 33222222222211111111110000000000
24464                                                      10987654321098765432109876543210
24465                                                      x0101111xxxxxxxx1100x0xxxxxxxxxx
24466                                                      fmlsl2.  */
24467                                                   return 2447;
24468                                                 }
24469                                               else
24470                                                 {
24471                                                   /* 33222222222211111111110000000000
24472                                                      10987654321098765432109876543210
24473                                                      x1101111xxxxxxxx1100x0xxxxxxxxxx
24474                                                      fmlsl2.  */
24475                                                   return 2451;
24476                                                 }
24477                                             }
24478                                         }
24479                                     }
24480                                   else
24481                                     {
24482                                       if (((word >> 14) & 0x1) == 0)
24483                                         {
24484                                           if (((word >> 29) & 0x1) == 0)
24485                                             {
24486                                               if (((word >> 30) & 0x1) == 0)
24487                                                 {
24488                                                   /* 33222222222211111111110000000000
24489                                                      10987654321098765432109876543210
24490                                                      x0001111xxxxxxxx1010x0xxxxxxxxxx
24491                                                      smull.  */
24492                                                   return 107;
24493                                                 }
24494                                               else
24495                                                 {
24496                                                   /* 33222222222211111111110000000000
24497                                                      10987654321098765432109876543210
24498                                                      x1001111xxxxxxxx1010x0xxxxxxxxxx
24499                                                      smull2.  */
24500                                                   return 108;
24501                                                 }
24502                                             }
24503                                           else
24504                                             {
24505                                               if (((word >> 30) & 0x1) == 0)
24506                                                 {
24507                                                   /* 33222222222211111111110000000000
24508                                                      10987654321098765432109876543210
24509                                                      x0101111xxxxxxxx1010x0xxxxxxxxxx
24510                                                      umull.  */
24511                                                   return 125;
24512                                                 }
24513                                               else
24514                                                 {
24515                                                   /* 33222222222211111111110000000000
24516                                                      10987654321098765432109876543210
24517                                                      x1101111xxxxxxxx1010x0xxxxxxxxxx
24518                                                      umull2.  */
24519                                                   return 126;
24520                                                 }
24521                                             }
24522                                         }
24523                                       else
24524                                         {
24525                                           if (((word >> 29) & 0x1) == 0)
24526                                             {
24527                                               /* 33222222222211111111110000000000
24528                                                  10987654321098765432109876543210
24529                                                  xx001111xxxxxxxx1110x0xxxxxxxxxx
24530                                                  sdot.  */
24531                                               return 2418;
24532                                             }
24533                                           else
24534                                             {
24535                                               /* 33222222222211111111110000000000
24536                                                  10987654321098765432109876543210
24537                                                  xx101111xxxxxxxx1110x0xxxxxxxxxx
24538                                                  udot.  */
24539                                               return 2417;
24540                                             }
24541                                         }
24542                                     }
24543                                 }
24544                               else
24545                                 {
24546                                   if (((word >> 13) & 0x1) == 0)
24547                                     {
24548                                       if (((word >> 14) & 0x1) == 0)
24549                                         {
24550                                           if (((word >> 23) & 0x1) == 0)
24551                                             {
24552                                               if (((word >> 29) & 0x1) == 0)
24553                                                 {
24554                                                   /* 33222222222211111111110000000000
24555                                                      10987654321098765432109876543210
24556                                                      xx0011110xxxxxxx1001x0xxxxxxxxxx
24557                                                      fmul.  */
24558                                                   return 118;
24559                                                 }
24560                                               else
24561                                                 {
24562                                                   /* 33222222222211111111110000000000
24563                                                      10987654321098765432109876543210
24564                                                      xx1011110xxxxxxx1001x0xxxxxxxxxx
24565                                                      fmulx.  */
24566                                                   return 128;
24567                                                 }
24568                                             }
24569                                           else
24570                                             {
24571                                               if (((word >> 29) & 0x1) == 0)
24572                                                 {
24573                                                   /* 33222222222211111111110000000000
24574                                                      10987654321098765432109876543210
24575                                                      xx0011111xxxxxxx1001x0xxxxxxxxxx
24576                                                      fmul.  */
24577                                                   return 117;
24578                                                 }
24579                                               else
24580                                                 {
24581                                                   /* 33222222222211111111110000000000
24582                                                      10987654321098765432109876543210
24583                                                      xx1011111xxxxxxx1001x0xxxxxxxxxx
24584                                                      fmulx.  */
24585                                                   return 127;
24586                                                 }
24587                                             }
24588                                         }
24589                                       else
24590                                         {
24591                                           if (((word >> 29) & 0x1) == 0)
24592                                             {
24593                                               /* 33222222222211111111110000000000
24594                                                  10987654321098765432109876543210
24595                                                  xx001111xxxxxxxx1101x0xxxxxxxxxx
24596                                                  sqrdmulh.  */
24597                                               return 112;
24598                                             }
24599                                           else
24600                                             {
24601                                               /* 33222222222211111111110000000000
24602                                                  10987654321098765432109876543210
24603                                                  xx101111xxxxxxxx1101x0xxxxxxxxxx
24604                                                  sqrdmlah.  */
24605                                               return 129;
24606                                             }
24607                                         }
24608                                     }
24609                                   else
24610                                     {
24611                                       if (((word >> 14) & 0x1) == 0)
24612                                         {
24613                                           if (((word >> 30) & 0x1) == 0)
24614                                             {
24615                                               /* 33222222222211111111110000000000
24616                                                  10987654321098765432109876543210
24617                                                  x0x01111xxxxxxxx1011x0xxxxxxxxxx
24618                                                  sqdmull.  */
24619                                               return 109;
24620                                             }
24621                                           else
24622                                             {
24623                                               /* 33222222222211111111110000000000
24624                                                  10987654321098765432109876543210
24625                                                  x1x01111xxxxxxxx1011x0xxxxxxxxxx
24626                                                  sqdmull2.  */
24627                                               return 110;
24628                                             }
24629                                         }
24630                                       else
24631                                         {
24632                                           if (((word >> 29) & 0x1) == 0)
24633                                             {
24634                                               if (((word >> 22) & 0x1) == 0)
24635                                                 {
24636                                                   if (((word >> 23) & 0x1) == 0)
24637                                                     {
24638                                                       /* 33222222222211111111110000000000
24639                                                          10987654321098765432109876543210
24640                                                          xx00111100xxxxxx1111x0xxxxxxxxxx
24641                                                          sudot.  */
24642                                                       return 2495;
24643                                                     }
24644                                                   else
24645                                                     {
24646                                                       /* 33222222222211111111110000000000
24647                                                          10987654321098765432109876543210
24648                                                          xx00111110xxxxxx1111x0xxxxxxxxxx
24649                                                          usdot.  */
24650                                                       return 2494;
24651                                                     }
24652                                                 }
24653                                               else
24654                                                 {
24655                                                   if (((word >> 23) & 0x1) == 0)
24656                                                     {
24657                                                       /* 33222222222211111111110000000000
24658                                                          10987654321098765432109876543210
24659                                                          xx00111101xxxxxx1111x0xxxxxxxxxx
24660                                                          bfdot.  */
24661                                                       return 2506;
24662                                                     }
24663                                                   else
24664                                                     {
24665                                                       if (((word >> 30) & 0x1) == 0)
24666                                                         {
24667                                                           /* 33222222222211111111110000000000
24668                                                              10987654321098765432109876543210
24669                                                              x000111111xxxxxx1111x0xxxxxxxxxx
24670                                                              bfmlalb.  */
24671                                                           return 2514;
24672                                                         }
24673                                                       else
24674                                                         {
24675                                                           /* 33222222222211111111110000000000
24676                                                              10987654321098765432109876543210
24677                                                              x100111111xxxxxx1111x0xxxxxxxxxx
24678                                                              bfmlalt.  */
24679                                                           return 2513;
24680                                                         }
24681                                                     }
24682                                                 }
24683                                             }
24684                                           else
24685                                             {
24686                                               /* 33222222222211111111110000000000
24687                                                  10987654321098765432109876543210
24688                                                  xx101111xxxxxxxx1111x0xxxxxxxxxx
24689                                                  sqrdmlsh.  */
24690                                               return 130;
24691                                             }
24692                                         }
24693                                     }
24694                                 }
24695                             }
24696                           else
24697                             {
24698                               if (((word >> 11) & 0x1) == 0)
24699                                 {
24700                                   if (((word >> 14) & 0x1) == 0)
24701                                     {
24702                                       if (((word >> 12) & 0x1) == 0)
24703                                         {
24704                                           if (((word >> 29) & 0x1) == 0)
24705                                             {
24706                                               /* 33222222222211111111110000000000
24707                                                  10987654321098765432109876543210
24708                                                  xx001111xxxxxxxx10x001xxxxxxxxxx
24709                                                  movi.  */
24710                                               return 135;
24711                                             }
24712                                           else
24713                                             {
24714                                               /* 33222222222211111111110000000000
24715                                                  10987654321098765432109876543210
24716                                                  xx101111xxxxxxxx10x001xxxxxxxxxx
24717                                                  mvni.  */
24718                                               return 143;
24719                                             }
24720                                         }
24721                                       else
24722                                         {
24723                                           if (((word >> 29) & 0x1) == 0)
24724                                             {
24725                                               /* 33222222222211111111110000000000
24726                                                  10987654321098765432109876543210
24727                                                  xx001111xxxxxxxx10x101xxxxxxxxxx
24728                                                  orr.  */
24729                                               return 136;
24730                                             }
24731                                           else
24732                                             {
24733                                               /* 33222222222211111111110000000000
24734                                                  10987654321098765432109876543210
24735                                                  xx101111xxxxxxxx10x101xxxxxxxxxx
24736                                                  bic.  */
24737                                               return 144;
24738                                             }
24739                                         }
24740                                     }
24741                                   else
24742                                     {
24743                                       if (((word >> 13) & 0x1) == 0)
24744                                         {
24745                                           if (((word >> 29) & 0x1) == 0)
24746                                             {
24747                                               /* 33222222222211111111110000000000
24748                                                  10987654321098765432109876543210
24749                                                  xx001111xxxxxxxx110x01xxxxxxxxxx
24750                                                  movi.  */
24751                                               return 137;
24752                                             }
24753                                           else
24754                                             {
24755                                               /* 33222222222211111111110000000000
24756                                                  10987654321098765432109876543210
24757                                                  xx101111xxxxxxxx110x01xxxxxxxxxx
24758                                                  mvni.  */
24759                                               return 145;
24760                                             }
24761                                         }
24762                                       else
24763                                         {
24764                                           if (((word >> 12) & 0x1) == 0)
24765                                             {
24766                                               if (((word >> 29) & 0x1) == 0)
24767                                                 {
24768                                                   /* 33222222222211111111110000000000
24769                                                      10987654321098765432109876543210
24770                                                      xx001111xxxxxxxx111001xxxxxxxxxx
24771                                                      movi.  */
24772                                                   return 138;
24773                                                 }
24774                                               else
24775                                                 {
24776                                                   /* 33222222222211111111110000000000
24777                                                      10987654321098765432109876543210
24778                                                      xx101111xxxxxxxx111001xxxxxxxxxx
24779                                                      movi.  */
24780                                                   return 146;
24781                                                 }
24782                                             }
24783                                           else
24784                                             {
24785                                               if (((word >> 29) & 0x1) == 0)
24786                                                 {
24787                                                   /* 33222222222211111111110000000000
24788                                                      10987654321098765432109876543210
24789                                                      xx001111xxxxxxxx111101xxxxxxxxxx
24790                                                      fmov.  */
24791                                                   return 139;
24792                                                 }
24793                                               else
24794                                                 {
24795                                                   /* 33222222222211111111110000000000
24796                                                      10987654321098765432109876543210
24797                                                      xx101111xxxxxxxx111101xxxxxxxxxx
24798                                                      fmov.  */
24799                                                   return 148;
24800                                                 }
24801                                             }
24802                                         }
24803                                     }
24804                                 }
24805                               else
24806                                 {
24807                                   if (((word >> 12) & 0x1) == 0)
24808                                     {
24809                                       if (((word >> 29) & 0x1) == 0)
24810                                         {
24811                                           if (((word >> 30) & 0x1) == 0)
24812                                             {
24813                                               /* 33222222222211111111110000000000
24814                                                  10987654321098765432109876543210
24815                                                  x0001111xxxxxxxx1xx011xxxxxxxxxx
24816                                                  rshrn.  */
24817                                               return 382;
24818                                             }
24819                                           else
24820                                             {
24821                                               /* 33222222222211111111110000000000
24822                                                  10987654321098765432109876543210
24823                                                  x1001111xxxxxxxx1xx011xxxxxxxxxx
24824                                                  rshrn2.  */
24825                                               return 383;
24826                                             }
24827                                         }
24828                                       else
24829                                         {
24830                                           if (((word >> 30) & 0x1) == 0)
24831                                             {
24832                                               /* 33222222222211111111110000000000
24833                                                  10987654321098765432109876543210
24834                                                  x0101111xxxxxxxx1xx011xxxxxxxxxx
24835                                                  sqrshrun.  */
24836                                               return 406;
24837                                             }
24838                                           else
24839                                             {
24840                                               /* 33222222222211111111110000000000
24841                                                  10987654321098765432109876543210
24842                                                  x1101111xxxxxxxx1xx011xxxxxxxxxx
24843                                                  sqrshrun2.  */
24844                                               return 407;
24845                                             }
24846                                         }
24847                                     }
24848                                   else
24849                                     {
24850                                       if (((word >> 13) & 0x1) == 0)
24851                                         {
24852                                           if (((word >> 29) & 0x1) == 0)
24853                                             {
24854                                               if (((word >> 30) & 0x1) == 0)
24855                                                 {
24856                                                   /* 33222222222211111111110000000000
24857                                                      10987654321098765432109876543210
24858                                                      x0001111xxxxxxxx1x0111xxxxxxxxxx
24859                                                      sqrshrn.  */
24860                                                   return 386;
24861                                                 }
24862                                               else
24863                                                 {
24864                                                   /* 33222222222211111111110000000000
24865                                                      10987654321098765432109876543210
24866                                                      x1001111xxxxxxxx1x0111xxxxxxxxxx
24867                                                      sqrshrn2.  */
24868                                                   return 387;
24869                                                 }
24870                                             }
24871                                           else
24872                                             {
24873                                               if (((word >> 30) & 0x1) == 0)
24874                                                 {
24875                                                   /* 33222222222211111111110000000000
24876                                                      10987654321098765432109876543210
24877                                                      x0101111xxxxxxxx1x0111xxxxxxxxxx
24878                                                      uqrshrn.  */
24879                                                   return 410;
24880                                                 }
24881                                               else
24882                                                 {
24883                                                   /* 33222222222211111111110000000000
24884                                                      10987654321098765432109876543210
24885                                                      x1101111xxxxxxxx1x0111xxxxxxxxxx
24886                                                      uqrshrn2.  */
24887                                                   return 411;
24888                                                 }
24889                                             }
24890                                         }
24891                                       else
24892                                         {
24893                                           if (((word >> 29) & 0x1) == 0)
24894                                             {
24895                                               /* 33222222222211111111110000000000
24896                                                  10987654321098765432109876543210
24897                                                  xx001111xxxxxxxx1x1111xxxxxxxxxx
24898                                                  fmov.  */
24899                                               return 140;
24900                                             }
24901                                           else
24902                                             {
24903                                               /* 33222222222211111111110000000000
24904                                                  10987654321098765432109876543210
24905                                                  xx101111xxxxxxxx1x1111xxxxxxxxxx
24906                                                  fcvtzu.  */
24907                                               return 418;
24908                                             }
24909                                         }
24910                                     }
24911                                 }
24912                             }
24913                         }
24914                       else
24915                         {
24916                           if (((word >> 29) & 0x1) == 0)
24917                             {
24918                               if (((word >> 30) & 0x1) == 0)
24919                                 {
24920                                   if (((word >> 21) & 0x1) == 0)
24921                                     {
24922                                       /* 33222222222211111111110000000000
24923                                          10987654321098765432109876543210
24924                                          x0011111xx0xxxxx1xxxxxxxxxxxxxxx
24925                                          fmsub.  */
24926                                       return 860;
24927                                     }
24928                                   else
24929                                     {
24930                                       /* 33222222222211111111110000000000
24931                                          10987654321098765432109876543210
24932                                          x0011111xx1xxxxx1xxxxxxxxxxxxxxx
24933                                          fnmsub.  */
24934                                       return 864;
24935                                     }
24936                                 }
24937                               else
24938                                 {
24939                                   if (((word >> 10) & 0x1) == 0)
24940                                     {
24941                                       if (((word >> 12) & 0x1) == 0)
24942                                         {
24943                                           /* 33222222222211111111110000000000
24944                                              10987654321098765432109876543210
24945                                              x1011111xxxxxxxx1xx0x0xxxxxxxxxx
24946                                              sqdmulh.  */
24947                                           return 428;
24948                                         }
24949                                       else
24950                                         {
24951                                           if (((word >> 13) & 0x1) == 0)
24952                                             {
24953                                               if (((word >> 14) & 0x1) == 0)
24954                                                 {
24955                                                   if (((word >> 23) & 0x1) == 0)
24956                                                     {
24957                                                       /* 33222222222211111111110000000000
24958                                                          10987654321098765432109876543210
24959                                                          x10111110xxxxxxx1001x0xxxxxxxxxx
24960                                                          fmul.  */
24961                                                       return 435;
24962                                                     }
24963                                                   else
24964                                                     {
24965                                                       /* 33222222222211111111110000000000
24966                                                          10987654321098765432109876543210
24967                                                          x10111111xxxxxxx1001x0xxxxxxxxxx
24968                                                          fmul.  */
24969                                                       return 434;
24970                                                     }
24971                                                 }
24972                                               else
24973                                                 {
24974                                                   /* 33222222222211111111110000000000
24975                                                      10987654321098765432109876543210
24976                                                      x1011111xxxxxxxx1101x0xxxxxxxxxx
24977                                                      sqrdmulh.  */
24978                                                   return 429;
24979                                                 }
24980                                             }
24981                                           else
24982                                             {
24983                                               /* 33222222222211111111110000000000
24984                                                  10987654321098765432109876543210
24985                                                  x1011111xxxxxxxx1x11x0xxxxxxxxxx
24986                                                  sqdmull.  */
24987                                               return 427;
24988                                             }
24989                                         }
24990                                     }
24991                                   else
24992                                     {
24993                                       if (((word >> 11) & 0x1) == 0)
24994                                         {
24995                                           if (((word >> 12) & 0x1) == 0)
24996                                             {
24997                                               /* 33222222222211111111110000000000
24998                                                  10987654321098765432109876543210
24999                                                  x1011111xxxxxxxx1xx001xxxxxxxxxx
25000                                                  scvtf.  */
25001                                               return 598;
25002                                             }
25003                                           else
25004                                             {
25005                                               /* 33222222222211111111110000000000
25006                                                  10987654321098765432109876543210
25007                                                  x1011111xxxxxxxx1xx101xxxxxxxxxx
25008                                                  sqshrn.  */
25009                                               return 596;
25010                                             }
25011                                         }
25012                                       else
25013                                         {
25014                                           if (((word >> 13) & 0x1) == 0)
25015                                             {
25016                                               /* 33222222222211111111110000000000
25017                                                  10987654321098765432109876543210
25018                                                  x1011111xxxxxxxx1x0x11xxxxxxxxxx
25019                                                  sqrshrn.  */
25020                                               return 597;
25021                                             }
25022                                           else
25023                                             {
25024                                               /* 33222222222211111111110000000000
25025                                                  10987654321098765432109876543210
25026                                                  x1011111xxxxxxxx1x1x11xxxxxxxxxx
25027                                                  fcvtzs.  */
25028                                               return 600;
25029                                             }
25030                                         }
25031                                     }
25032                                 }
25033                             }
25034                           else
25035                             {
25036                               if (((word >> 10) & 0x1) == 0)
25037                                 {
25038                                   if (((word >> 13) & 0x1) == 0)
25039                                     {
25040                                       if (((word >> 14) & 0x1) == 0)
25041                                         {
25042                                           if (((word >> 23) & 0x1) == 0)
25043                                             {
25044                                               /* 33222222222211111111110000000000
25045                                                  10987654321098765432109876543210
25046                                                  xx1111110xxxxxxx100xx0xxxxxxxxxx
25047                                                  fmulx.  */
25048                                               return 437;
25049                                             }
25050                                           else
25051                                             {
25052                                               /* 33222222222211111111110000000000
25053                                                  10987654321098765432109876543210
25054                                                  xx1111111xxxxxxx100xx0xxxxxxxxxx
25055                                                  fmulx.  */
25056                                               return 436;
25057                                             }
25058                                         }
25059                                       else
25060                                         {
25061                                           /* 33222222222211111111110000000000
25062                                              10987654321098765432109876543210
25063                                              xx111111xxxxxxxx110xx0xxxxxxxxxx
25064                                              sqrdmlah.  */
25065                                           return 438;
25066                                         }
25067                                     }
25068                                   else
25069                                     {
25070                                       /* 33222222222211111111110000000000
25071                                          10987654321098765432109876543210
25072                                          xx111111xxxxxxxx1x1xx0xxxxxxxxxx
25073                                          sqrdmlsh.  */
25074                                       return 439;
25075                                     }
25076                                 }
25077                               else
25078                                 {
25079                                   if (((word >> 11) & 0x1) == 0)
25080                                     {
25081                                       if (((word >> 12) & 0x1) == 0)
25082                                         {
25083                                           if (((word >> 13) & 0x1) == 0)
25084                                             {
25085                                               /* 33222222222211111111110000000000
25086                                                  10987654321098765432109876543210
25087                                                  xx111111xxxxxxxx1x0001xxxxxxxxxx
25088                                                  sqshrun.  */
25089                                               return 610;
25090                                             }
25091                                           else
25092                                             {
25093                                               /* 33222222222211111111110000000000
25094                                                  10987654321098765432109876543210
25095                                                  xx111111xxxxxxxx1x1001xxxxxxxxxx
25096                                                  ucvtf.  */
25097                                               return 614;
25098                                             }
25099                                         }
25100                                       else
25101                                         {
25102                                           /* 33222222222211111111110000000000
25103                                              10987654321098765432109876543210
25104                                              xx111111xxxxxxxx1xx101xxxxxxxxxx
25105                                              uqshrn.  */
25106                                           return 612;
25107                                         }
25108                                     }
25109                                   else
25110                                     {
25111                                       if (((word >> 12) & 0x1) == 0)
25112                                         {
25113                                           /* 33222222222211111111110000000000
25114                                              10987654321098765432109876543210
25115                                              xx111111xxxxxxxx1xx011xxxxxxxxxx
25116                                              sqrshrun.  */
25117                                           return 611;
25118                                         }
25119                                       else
25120                                         {
25121                                           if (((word >> 13) & 0x1) == 0)
25122                                             {
25123                                               /* 33222222222211111111110000000000
25124                                                  10987654321098765432109876543210
25125                                                  xx111111xxxxxxxx1x0111xxxxxxxxxx
25126                                                  uqrshrn.  */
25127                                               return 613;
25128                                             }
25129                                           else
25130                                             {
25131                                               /* 33222222222211111111110000000000
25132                                                  10987654321098765432109876543210
25133                                                  xx111111xxxxxxxx1x1111xxxxxxxxxx
25134                                                  fcvtzu.  */
25135                                               return 616;
25136                                             }
25137                                         }
25138                                     }
25139                                 }
25140                             }
25141                         }
25142                     }
25143                 }
25144             }
25145         }
25146     }
25147 }
25148
25149 /* Lookup opcode WORD in the opcode table.  N.B. all alias
25150    opcodes are ignored here.  */
25151
25152 const aarch64_opcode *
25153 aarch64_opcode_lookup (uint32_t word)
25154 {
25155   return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);
25156 }
25157
25158 const aarch64_opcode *
25159 aarch64_find_next_opcode (const aarch64_opcode *opcode)
25160 {
25161   /* Use the index as the key to locate the next opcode.  */
25162   int key = opcode - aarch64_opcode_table;
25163   int value;
25164   switch (key)
25165     {
25166     case 2385: value = 2387; break;     /* mov --> mova.  */
25167     case 2387: return NULL;             /* mova --> NULL.  */
25168     case 2384: value = 2386; break;     /* mov --> mova.  */
25169     case 2386: return NULL;             /* mova --> NULL.  */
25170     case 2389: value = 2394; break;     /* ld1b --> ld1b.  */
25171     case 2394: return NULL;             /* ld1b --> NULL.  */
25172     case 2391: value = 2396; break;     /* ld1w --> ld1w.  */
25173     case 2396: return NULL;             /* ld1w --> NULL.  */
25174     case 2390: value = 2395; break;     /* ld1h --> ld1h.  */
25175     case 2395: return NULL;             /* ld1h --> NULL.  */
25176     case 2392: value = 2397; break;     /* ld1d --> ld1d.  */
25177     case 2397: return NULL;             /* ld1d --> NULL.  */
25178     case 2399: value = 2404; break;     /* st1b --> st1b.  */
25179     case 2404: return NULL;             /* st1b --> NULL.  */
25180     case 2401: value = 2406; break;     /* st1w --> st1w.  */
25181     case 2406: return NULL;             /* st1w --> NULL.  */
25182     case 2400: value = 2405; break;     /* st1h --> st1h.  */
25183     case 2405: return NULL;             /* st1h --> NULL.  */
25184     case 2402: value = 2407; break;     /* st1d --> st1d.  */
25185     case 2407: return NULL;             /* st1d --> NULL.  */
25186     case 2393: value = 2398; break;     /* ld1q --> ld1q.  */
25187     case 2398: return NULL;             /* ld1q --> NULL.  */
25188     case 2403: value = 2408; break;     /* st1q --> st1q.  */
25189     case 2408: return NULL;             /* st1q --> NULL.  */
25190     case 12: value = 19; break; /* add --> addg.  */
25191     case 19: value = 2636; break;       /* addg --> smax.  */
25192     case 2636: value = 2637; break;     /* smax --> umax.  */
25193     case 2637: value = 2638; break;     /* umax --> smin.  */
25194     case 2638: value = 2639; break;     /* smin --> umin.  */
25195     case 2639: return NULL;             /* umin --> NULL.  */
25196     case 16: value = 20; break; /* sub --> subg.  */
25197     case 20: return NULL;               /* subg --> NULL.  */
25198     case 971: value = 975; break;       /* stnp --> stp.  */
25199     case 975: return NULL;              /* stp --> NULL.  */
25200     case 969: value = 970; break;       /* stllrb --> stllrh.  */
25201     case 970: return NULL;              /* stllrh --> NULL.  */
25202     case 972: value = 976; break;       /* ldnp --> ldp.  */
25203     case 976: return NULL;              /* ldp --> NULL.  */
25204     case 1641: value = 1642; break;     /* ldff1b --> ldff1b.  */
25205     case 1642: return NULL;             /* ldff1b --> NULL.  */
25206     case 1697: value = 1698; break;     /* ldff1sw --> ldff1sw.  */
25207     case 1698: return NULL;             /* ldff1sw --> NULL.  */
25208     case 1645: value = 1646; break;     /* ldff1b --> ldff1b.  */
25209     case 1646: return NULL;             /* ldff1b --> NULL.  */
25210     case 1664: value = 1665; break;     /* ldff1h --> ldff1h.  */
25211     case 1665: return NULL;             /* ldff1h --> NULL.  */
25212     case 1643: value = 1644; break;     /* ldff1b --> ldff1b.  */
25213     case 1644: return NULL;             /* ldff1b --> NULL.  */
25214     case 1662: value = 1663; break;     /* ldff1h --> ldff1h.  */
25215     case 1663: return NULL;             /* ldff1h --> NULL.  */
25216     case 1647: value = 1648; break;     /* ldff1b --> ldff1b.  */
25217     case 1648: return NULL;             /* ldff1b --> NULL.  */
25218     case 1666: value = 1667; break;     /* ldff1h --> ldff1h.  */
25219     case 1667: return NULL;             /* ldff1h --> NULL.  */
25220     case 1687: value = 1688; break;     /* ldff1sh --> ldff1sh.  */
25221     case 1688: return NULL;             /* ldff1sh --> NULL.  */
25222     case 1675: value = 1676; break;     /* ldff1sb --> ldff1sb.  */
25223     case 1676: return NULL;             /* ldff1sb --> NULL.  */
25224     case 1706: value = 1707; break;     /* ldff1w --> ldff1w.  */
25225     case 1707: return NULL;             /* ldff1w --> NULL.  */
25226     case 1679: value = 1680; break;     /* ldff1sb --> ldff1sb.  */
25227     case 1680: return NULL;             /* ldff1sb --> NULL.  */
25228     case 1689: value = 1690; break;     /* ldff1sh --> ldff1sh.  */
25229     case 1690: return NULL;             /* ldff1sh --> NULL.  */
25230     case 1677: value = 1678; break;     /* ldff1sb --> ldff1sb.  */
25231     case 1678: return NULL;             /* ldff1sb --> NULL.  */
25232     case 1708: value = 1709; break;     /* ldff1w --> ldff1w.  */
25233     case 1709: return NULL;             /* ldff1w --> NULL.  */
25234     case 1653: value = 1654; break;     /* ldff1d --> ldff1d.  */
25235     case 1654: return NULL;             /* ldff1d --> NULL.  */
25236     case 811: value = 812; break;       /* xaflag --> axflag.  */
25237     case 812: value = 1194; break;      /* axflag --> tcommit.  */
25238     case 1194: value = 1197; break;     /* tcommit --> smstart.  */
25239     case 1197: value = 1198; break;     /* smstart --> smstop.  */
25240     case 1198: value = 1199; break;     /* smstop --> smstart.  */
25241     case 1199: value = 1200; break;     /* smstart --> smstop.  */
25242     case 1200: value = 1201; break;     /* smstop --> msr.  */
25243     case 1201: value = 1202; break;     /* msr --> hint.  */
25244     case 1202: value = 1211; break;     /* hint --> dgh.  */
25245     case 1211: value = 1221; break;     /* dgh --> clrex.  */
25246     case 1221: value = 1222; break;     /* clrex --> dsb.  */
25247     case 1222: value = 1223; break;     /* dsb --> dsb.  */
25248     case 1223: value = 1227; break;     /* dsb --> dmb.  */
25249     case 1227: value = 1228; break;     /* dmb --> isb.  */
25250     case 1228: value = 1229; break;     /* isb --> sb.  */
25251     case 1229: value = 1230; break;     /* sb --> sys.  */
25252     case 1230: value = 1235; break;     /* sys --> wfet.  */
25253     case 1235: value = 1236; break;     /* wfet --> wfit.  */
25254     case 1236: value = 1240; break;     /* wfit --> cfinv.  */
25255     case 1240: value = 1241; break;     /* cfinv --> msr.  */
25256     case 1241: return NULL;             /* msr --> NULL.  */
25257     case 1193: value = 1195; break;     /* tstart --> ttest.  */
25258     case 1195: value = 1242; break;     /* ttest --> sysl.  */
25259     case 1242: value = 1243; break;     /* sysl --> mrs.  */
25260     case 1243: return NULL;             /* mrs --> NULL.  */
25261     case 440: value = 441; break;       /* st4 --> st1.  */
25262     case 441: value = 442; break;       /* st1 --> st2.  */
25263     case 442: value = 443; break;       /* st2 --> st3.  */
25264     case 443: return NULL;              /* st3 --> NULL.  */
25265     case 448: value = 449; break;       /* st4 --> st1.  */
25266     case 449: value = 450; break;       /* st1 --> st2.  */
25267     case 450: value = 451; break;       /* st2 --> st3.  */
25268     case 451: return NULL;              /* st3 --> NULL.  */
25269     case 444: value = 445; break;       /* ld4 --> ld1.  */
25270     case 445: value = 446; break;       /* ld1 --> ld2.  */
25271     case 446: value = 447; break;       /* ld2 --> ld3.  */
25272     case 447: return NULL;              /* ld3 --> NULL.  */
25273     case 460: value = 462; break;       /* ld1 --> ld1r.  */
25274     case 462: return NULL;              /* ld1r --> NULL.  */
25275     case 464: value = 466; break;       /* ld2 --> ld2r.  */
25276     case 466: return NULL;              /* ld2r --> NULL.  */
25277     case 461: value = 463; break;       /* ld3 --> ld3r.  */
25278     case 463: return NULL;              /* ld3r --> NULL.  */
25279     case 465: value = 467; break;       /* ld4 --> ld4r.  */
25280     case 467: return NULL;              /* ld4r --> NULL.  */
25281     case 452: value = 453; break;       /* ld4 --> ld1.  */
25282     case 453: value = 454; break;       /* ld1 --> ld2.  */
25283     case 454: value = 455; break;       /* ld2 --> ld3.  */
25284     case 455: return NULL;              /* ld3 --> NULL.  */
25285     case 472: value = 474; break;       /* ld1 --> ld1r.  */
25286     case 474: return NULL;              /* ld1r --> NULL.  */
25287     case 473: value = 475; break;       /* ld3 --> ld3r.  */
25288     case 475: return NULL;              /* ld3r --> NULL.  */
25289     case 476: value = 478; break;       /* ld2 --> ld2r.  */
25290     case 478: return NULL;              /* ld2r --> NULL.  */
25291     case 477: value = 479; break;       /* ld4 --> ld4r.  */
25292     case 479: return NULL;              /* ld4r --> NULL.  */
25293     case 764: value = 765; break;       /* fcvtzs --> fcvtzs.  */
25294     case 765: return NULL;              /* fcvtzs --> NULL.  */
25295     case 760: value = 761; break;       /* scvtf --> scvtf.  */
25296     case 761: return NULL;              /* scvtf --> NULL.  */
25297     case 766: value = 767; break;       /* fcvtzu --> fcvtzu.  */
25298     case 767: return NULL;              /* fcvtzu --> NULL.  */
25299     case 762: value = 763; break;       /* ucvtf --> ucvtf.  */
25300     case 763: return NULL;              /* ucvtf --> NULL.  */
25301     case 768: value = 769; break;       /* fcvtns --> fcvtns.  */
25302     case 769: return NULL;              /* fcvtns --> NULL.  */
25303     case 788: value = 789; break;       /* fcvtms --> fcvtms.  */
25304     case 789: return NULL;              /* fcvtms --> NULL.  */
25305     case 784: value = 785; break;       /* fcvtps --> fcvtps.  */
25306     case 785: return NULL;              /* fcvtps --> NULL.  */
25307     case 792: value = 793; break;       /* fcvtzs --> fcvtzs.  */
25308     case 793: return NULL;              /* fcvtzs --> NULL.  */
25309     case 776: value = 777; break;       /* fcvtas --> fcvtas.  */
25310     case 777: return NULL;              /* fcvtas --> NULL.  */
25311     case 772: value = 773; break;       /* scvtf --> scvtf.  */
25312     case 773: return NULL;              /* scvtf --> NULL.  */
25313     case 780: value = 781; break;       /* fmov --> fmov.  */
25314     case 781: return NULL;              /* fmov --> NULL.  */
25315     case 770: value = 771; break;       /* fcvtnu --> fcvtnu.  */
25316     case 771: return NULL;              /* fcvtnu --> NULL.  */
25317     case 790: value = 791; break;       /* fcvtmu --> fcvtmu.  */
25318     case 791: return NULL;              /* fcvtmu --> NULL.  */
25319     case 786: value = 787; break;       /* fcvtpu --> fcvtpu.  */
25320     case 787: return NULL;              /* fcvtpu --> NULL.  */
25321     case 794: value = 795; break;       /* fcvtzu --> fcvtzu.  */
25322     case 795: return NULL;              /* fcvtzu --> NULL.  */
25323     case 778: value = 779; break;       /* fcvtau --> fcvtau.  */
25324     case 779: return NULL;              /* fcvtau --> NULL.  */
25325     case 774: value = 775; break;       /* ucvtf --> ucvtf.  */
25326     case 775: return NULL;              /* ucvtf --> NULL.  */
25327     case 782: value = 783; break;       /* fmov --> fmov.  */
25328     case 783: return NULL;              /* fmov --> NULL.  */
25329     case 817: value = 818; break;       /* fmov --> fmov.  */
25330     case 818: return NULL;              /* fmov --> NULL.  */
25331     case 826: value = 827; break;       /* frintn --> frintn.  */
25332     case 827: return NULL;              /* frintn --> NULL.  */
25333     case 821: value = 822; break;       /* fneg --> fneg.  */
25334     case 822: return NULL;              /* fneg --> NULL.  */
25335     case 830: value = 831; break;       /* frintm --> frintm.  */
25336     case 831: return NULL;              /* frintm --> NULL.  */
25337     case 819: value = 820; break;       /* fabs --> fabs.  */
25338     case 820: return NULL;              /* fabs --> NULL.  */
25339     case 828: value = 829; break;       /* frintp --> frintp.  */
25340     case 829: return NULL;              /* frintp --> NULL.  */
25341     case 823: value = 824; break;       /* fsqrt --> fsqrt.  */
25342     case 824: return NULL;              /* fsqrt --> NULL.  */
25343     case 832: value = 833; break;       /* frintz --> frintz.  */
25344     case 833: return NULL;              /* frintz --> NULL.  */
25345     case 825: value = 2510; break;      /* fcvt --> bfcvt.  */
25346     case 2510: return NULL;             /* bfcvt --> NULL.  */
25347     case 834: value = 835; break;       /* frinta --> frinta.  */
25348     case 835: return NULL;              /* frinta --> NULL.  */
25349     case 836: value = 837; break;       /* frintx --> frintx.  */
25350     case 837: return NULL;              /* frintx --> NULL.  */
25351     case 838: value = 839; break;       /* frinti --> frinti.  */
25352     case 839: return NULL;              /* frinti --> NULL.  */
25353     case 803: value = 804; break;       /* fcmp --> fcmp.  */
25354     case 804: return NULL;              /* fcmp --> NULL.  */
25355     case 805: value = 806; break;       /* fcmpe --> fcmpe.  */
25356     case 806: return NULL;              /* fcmpe --> NULL.  */
25357     case 807: value = 808; break;       /* fcmp --> fcmp.  */
25358     case 808: return NULL;              /* fcmp --> NULL.  */
25359     case 809: value = 810; break;       /* fcmpe --> fcmpe.  */
25360     case 810: return NULL;              /* fcmpe --> NULL.  */
25361     case 866: value = 867; break;       /* fmov --> fmov.  */
25362     case 867: return NULL;              /* fmov --> NULL.  */
25363     case 840: value = 841; break;       /* fmul --> fmul.  */
25364     case 841: return NULL;              /* fmul --> NULL.  */
25365     case 856: value = 857; break;       /* fnmul --> fnmul.  */
25366     case 857: return NULL;              /* fnmul --> NULL.  */
25367     case 848: value = 849; break;       /* fmax --> fmax.  */
25368     case 849: return NULL;              /* fmax --> NULL.  */
25369     case 844: value = 845; break;       /* fadd --> fadd.  */
25370     case 845: return NULL;              /* fadd --> NULL.  */
25371     case 852: value = 853; break;       /* fmaxnm --> fmaxnm.  */
25372     case 853: return NULL;              /* fmaxnm --> NULL.  */
25373     case 842: value = 843; break;       /* fdiv --> fdiv.  */
25374     case 843: return NULL;              /* fdiv --> NULL.  */
25375     case 850: value = 851; break;       /* fmin --> fmin.  */
25376     case 851: return NULL;              /* fmin --> NULL.  */
25377     case 846: value = 847; break;       /* fsub --> fsub.  */
25378     case 847: return NULL;              /* fsub --> NULL.  */
25379     case 854: value = 855; break;       /* fminnm --> fminnm.  */
25380     case 855: return NULL;              /* fminnm --> NULL.  */
25381     case 799: value = 800; break;       /* fccmp --> fccmp.  */
25382     case 800: return NULL;              /* fccmp --> NULL.  */
25383     case 801: value = 802; break;       /* fccmpe --> fccmpe.  */
25384     case 802: return NULL;              /* fccmpe --> NULL.  */
25385     case 868: value = 869; break;       /* fcsel --> fcsel.  */
25386     case 869: return NULL;              /* fcsel --> NULL.  */
25387     case 133: value = 374; break;       /* movi --> sshr.  */
25388     case 374: value = 376; break;       /* sshr --> srshr.  */
25389     case 376: return NULL;              /* srshr --> NULL.  */
25390     case 141: value = 396; break;       /* mvni --> ushr.  */
25391     case 396: value = 398; break;       /* ushr --> urshr.  */
25392     case 398: value = 400; break;       /* urshr --> sri.  */
25393     case 400: value = 402; break;       /* sri --> sqshlu.  */
25394     case 402: return NULL;              /* sqshlu --> NULL.  */
25395     case 134: value = 375; break;       /* orr --> ssra.  */
25396     case 375: value = 377; break;       /* ssra --> srsra.  */
25397     case 377: value = 378; break;       /* srsra --> shl.  */
25398     case 378: value = 379; break;       /* shl --> sqshl.  */
25399     case 379: return NULL;              /* sqshl --> NULL.  */
25400     case 142: value = 397; break;       /* bic --> usra.  */
25401     case 397: value = 399; break;       /* usra --> ursra.  */
25402     case 399: value = 401; break;       /* ursra --> sli.  */
25403     case 401: value = 403; break;       /* sli --> uqshl.  */
25404     case 403: return NULL;              /* uqshl --> NULL.  */
25405     case 858: value = 859; break;       /* fmadd --> fmadd.  */
25406     case 859: return NULL;              /* fmadd --> NULL.  */
25407     case 862: value = 863; break;       /* fnmadd --> fnmadd.  */
25408     case 863: return NULL;              /* fnmadd --> NULL.  */
25409     case 135: value = 380; break;       /* movi --> shrn.  */
25410     case 380: value = 381; break;       /* shrn --> shrn2.  */
25411     case 381: value = 388; break;       /* shrn2 --> sshll.  */
25412     case 388: value = 390; break;       /* sshll --> sshll2.  */
25413     case 390: return NULL;              /* sshll2 --> NULL.  */
25414     case 143: value = 404; break;       /* mvni --> sqshrun.  */
25415     case 404: value = 405; break;       /* sqshrun --> sqshrun2.  */
25416     case 405: value = 412; break;       /* sqshrun2 --> ushll.  */
25417     case 412: value = 414; break;       /* ushll --> ushll2.  */
25418     case 414: return NULL;              /* ushll2 --> NULL.  */
25419     case 136: value = 384; break;       /* orr --> sqshrn.  */
25420     case 384: value = 385; break;       /* sqshrn --> sqshrn2.  */
25421     case 385: return NULL;              /* sqshrn2 --> NULL.  */
25422     case 144: value = 408; break;       /* bic --> uqshrn.  */
25423     case 408: value = 409; break;       /* uqshrn --> uqshrn2.  */
25424     case 409: return NULL;              /* uqshrn2 --> NULL.  */
25425     case 138: value = 392; break;       /* movi --> scvtf.  */
25426     case 392: value = 393; break;       /* scvtf --> scvtf.  */
25427     case 393: return NULL;              /* scvtf --> NULL.  */
25428     case 146: value = 147; break;       /* movi --> movi.  */
25429     case 147: value = 416; break;       /* movi --> ucvtf.  */
25430     case 416: value = 417; break;       /* ucvtf --> ucvtf.  */
25431     case 417: return NULL;              /* ucvtf --> NULL.  */
25432     case 140: value = 394; break;       /* fmov --> fcvtzs.  */
25433     case 394: value = 395; break;       /* fcvtzs --> fcvtzs.  */
25434     case 395: return NULL;              /* fcvtzs --> NULL.  */
25435     case 418: value = 419; break;       /* fcvtzu --> fcvtzu.  */
25436     case 419: return NULL;              /* fcvtzu --> NULL.  */
25437     case 860: value = 861; break;       /* fmsub --> fmsub.  */
25438     case 861: return NULL;              /* fmsub --> NULL.  */
25439     case 864: value = 865; break;       /* fnmsub --> fnmsub.  */
25440     case 865: return NULL;              /* fnmsub --> NULL.  */
25441     case 598: value = 599; break;       /* scvtf --> scvtf.  */
25442     case 599: return NULL;              /* scvtf --> NULL.  */
25443     case 600: value = 601; break;       /* fcvtzs --> fcvtzs.  */
25444     case 601: return NULL;              /* fcvtzs --> NULL.  */
25445     case 614: value = 615; break;       /* ucvtf --> ucvtf.  */
25446     case 615: return NULL;              /* ucvtf --> NULL.  */
25447     case 616: value = 617; break;       /* fcvtzu --> fcvtzu.  */
25448     case 617: return NULL;              /* fcvtzu --> NULL.  */
25449     default: return NULL;
25450     }
25451
25452   return aarch64_opcode_table + value;
25453 }
25454
25455 const aarch64_opcode *
25456 aarch64_find_alias_opcode (const aarch64_opcode *opcode)
25457 {
25458   /* Use the index as the key to locate the alias opcode.  */
25459   int key = opcode - aarch64_opcode_table;
25460   int value;
25461   switch (key)
25462     {
25463     case 2: value = 3; break;   /* sbc --> ngc.  */
25464     case 4: value = 5; break;   /* sbcs --> ngcs.  */
25465     case 7: value = 8; break;   /* adds --> cmn.  */
25466     case 10: value = 11; break; /* subs --> cmp.  */
25467     case 12: value = 13; break; /* add --> mov.  */
25468     case 14: value = 15; break; /* adds --> cmn.  */
25469     case 17: value = 18; break; /* subs --> cmp.  */
25470     case 22: value = 23; break; /* adds --> cmn.  */
25471     case 24: value = 25; break; /* sub --> neg.  */
25472     case 26: value = 27; break; /* subs --> cmp.  */
25473     case 152: value = 153; break;       /* umov --> mov.  */
25474     case 154: value = 155; break;       /* ins --> mov.  */
25475     case 156: value = 157; break;       /* ins --> mov.  */
25476     case 242: value = 243; break;       /* not --> mvn.  */
25477     case 317: value = 318; break;       /* orr --> mov.  */
25478     case 388: value = 389; break;       /* sshll --> sxtl.  */
25479     case 390: value = 391; break;       /* sshll2 --> sxtl2.  */
25480     case 412: value = 413; break;       /* ushll --> uxtl.  */
25481     case 414: value = 415; break;       /* ushll2 --> uxtl2.  */
25482     case 535: value = 536; break;       /* dup --> mov.  */
25483     case 618: value = 623; break;       /* sbfm --> sxtw.  */
25484     case 625: value = 627; break;       /* bfm --> bfc.  */
25485     case 629: value = 633; break;       /* ubfm --> uxth.  */
25486     case 663: value = 665; break;       /* csinc --> cset.  */
25487     case 666: value = 668; break;       /* csinv --> csetm.  */
25488     case 669: value = 670; break;       /* csneg --> cneg.  */
25489     case 688: value = 688; break;       /* rev --> rev.  */
25490     case 713: value = 714; break;       /* lslv --> lsl.  */
25491     case 715: value = 716; break;       /* lsrv --> lsr.  */
25492     case 717: value = 718; break;       /* asrv --> asr.  */
25493     case 719: value = 720; break;       /* rorv --> ror.  */
25494     case 722: value = 723; break;       /* subps --> cmpp.  */
25495     case 735: value = 736; break;       /* madd --> mul.  */
25496     case 737: value = 738; break;       /* msub --> mneg.  */
25497     case 739: value = 740; break;       /* smaddl --> smull.  */
25498     case 741: value = 742; break;       /* smsubl --> smnegl.  */
25499     case 744: value = 745; break;       /* umaddl --> umull.  */
25500     case 746: value = 747; break;       /* umsubl --> umnegl.  */
25501     case 758: value = 759; break;       /* extr --> ror.  */
25502     case 995: value = 996; break;       /* and --> bic.  */
25503     case 997: value = 998; break;       /* orr --> mov.  */
25504     case 1000: value = 1001; break;     /* ands --> tst.  */
25505     case 1004: value = 1006; break;     /* orr --> uxtw.  */
25506     case 1007: value = 1008; break;     /* orn --> mvn.  */
25507     case 1011: value = 1012; break;     /* ands --> tst.  */
25508     case 1042: value = 1138; break;     /* ldaddb --> staddb.  */
25509     case 1043: value = 1139; break;     /* ldaddh --> staddh.  */
25510     case 1044: value = 1140; break;     /* ldadd --> stadd.  */
25511     case 1046: value = 1141; break;     /* ldaddlb --> staddlb.  */
25512     case 1049: value = 1142; break;     /* ldaddlh --> staddlh.  */
25513     case 1052: value = 1143; break;     /* ldaddl --> staddl.  */
25514     case 1054: value = 1144; break;     /* ldclrb --> stclrb.  */
25515     case 1055: value = 1145; break;     /* ldclrh --> stclrh.  */
25516     case 1056: value = 1146; break;     /* ldclr --> stclr.  */
25517     case 1058: value = 1147; break;     /* ldclrlb --> stclrlb.  */
25518     case 1061: value = 1148; break;     /* ldclrlh --> stclrlh.  */
25519     case 1064: value = 1149; break;     /* ldclrl --> stclrl.  */
25520     case 1066: value = 1150; break;     /* ldeorb --> steorb.  */
25521     case 1067: value = 1151; break;     /* ldeorh --> steorh.  */
25522     case 1068: value = 1152; break;     /* ldeor --> steor.  */
25523     case 1070: value = 1153; break;     /* ldeorlb --> steorlb.  */
25524     case 1073: value = 1154; break;     /* ldeorlh --> steorlh.  */
25525     case 1076: value = 1155; break;     /* ldeorl --> steorl.  */
25526     case 1078: value = 1156; break;     /* ldsetb --> stsetb.  */
25527     case 1079: value = 1157; break;     /* ldseth --> stseth.  */
25528     case 1080: value = 1158; break;     /* ldset --> stset.  */
25529     case 1082: value = 1159; break;     /* ldsetlb --> stsetlb.  */
25530     case 1085: value = 1160; break;     /* ldsetlh --> stsetlh.  */
25531     case 1088: value = 1161; break;     /* ldsetl --> stsetl.  */
25532     case 1090: value = 1162; break;     /* ldsmaxb --> stsmaxb.  */
25533     case 1091: value = 1163; break;     /* ldsmaxh --> stsmaxh.  */
25534     case 1092: value = 1164; break;     /* ldsmax --> stsmax.  */
25535     case 1094: value = 1165; break;     /* ldsmaxlb --> stsmaxlb.  */
25536     case 1097: value = 1166; break;     /* ldsmaxlh --> stsmaxlh.  */
25537     case 1100: value = 1167; break;     /* ldsmaxl --> stsmaxl.  */
25538     case 1102: value = 1168; break;     /* ldsminb --> stsminb.  */
25539     case 1103: value = 1169; break;     /* ldsminh --> stsminh.  */
25540     case 1104: value = 1170; break;     /* ldsmin --> stsmin.  */
25541     case 1106: value = 1171; break;     /* ldsminlb --> stsminlb.  */
25542     case 1109: value = 1172; break;     /* ldsminlh --> stsminlh.  */
25543     case 1112: value = 1173; break;     /* ldsminl --> stsminl.  */
25544     case 1114: value = 1174; break;     /* ldumaxb --> stumaxb.  */
25545     case 1115: value = 1175; break;     /* ldumaxh --> stumaxh.  */
25546     case 1116: value = 1176; break;     /* ldumax --> stumax.  */
25547     case 1118: value = 1177; break;     /* ldumaxlb --> stumaxlb.  */
25548     case 1121: value = 1178; break;     /* ldumaxlh --> stumaxlh.  */
25549     case 1124: value = 1179; break;     /* ldumaxl --> stumaxl.  */
25550     case 1126: value = 1180; break;     /* lduminb --> stuminb.  */
25551     case 1127: value = 1181; break;     /* lduminh --> stuminh.  */
25552     case 1128: value = 1182; break;     /* ldumin --> stumin.  */
25553     case 1130: value = 1183; break;     /* lduminlb --> stuminlb.  */
25554     case 1133: value = 1184; break;     /* lduminlh --> stuminlh.  */
25555     case 1136: value = 1185; break;     /* lduminl --> stuminl.  */
25556     case 1186: value = 1187; break;     /* movn --> mov.  */
25557     case 1188: value = 1189; break;     /* movz --> mov.  */
25558     case 1202: value = 1251; break;     /* hint --> autibsp.  */
25559     case 1222: value = 1226; break;     /* dsb --> pssbb.  */
25560     case 1223: value = 1223; break;     /* dsb --> dsb.  */
25561     case 1230: value = 1239; break;     /* sys --> cpp.  */
25562     case 1235: value = 1235; break;     /* wfet --> wfet.  */
25563     case 1236: value = 1236; break;     /* wfit --> wfit.  */
25564     case 1299: value = 2049; break;     /* and --> bic.  */
25565     case 1301: value = 1282; break;     /* and --> mov.  */
25566     case 1302: value = 1286; break;     /* ands --> movs.  */
25567     case 1337: value = 2050; break;     /* cmpge --> cmple.  */
25568     case 1340: value = 2053; break;     /* cmpgt --> cmplt.  */
25569     case 1342: value = 2051; break;     /* cmphi --> cmplo.  */
25570     case 1345: value = 2052; break;     /* cmphs --> cmpls.  */
25571     case 1367: value = 1279; break;     /* cpy --> mov.  */
25572     case 1368: value = 1281; break;     /* cpy --> mov.  */
25573     case 1369: value = 2060; break;     /* cpy --> fmov.  */
25574     case 1381: value = 1274; break;     /* dup --> mov.  */
25575     case 1382: value = 1276; break;     /* dup --> mov.  */
25576     case 1383: value = 2059; break;     /* dup --> fmov.  */
25577     case 1384: value = 1277; break;     /* dupm --> mov.  */
25578     case 1386: value = 2054; break;     /* eor --> eon.  */
25579     case 1388: value = 1287; break;     /* eor --> not.  */
25580     case 1389: value = 1288; break;     /* eors --> nots.  */
25581     case 1394: value = 2055; break;     /* facge --> facle.  */
25582     case 1395: value = 2056; break;     /* facgt --> faclt.  */
25583     case 1408: value = 2057; break;     /* fcmge --> fcmle.  */
25584     case 1410: value = 2058; break;     /* fcmgt --> fcmlt.  */
25585     case 1416: value = 1271; break;     /* fcpy --> fmov.  */
25586     case 1439: value = 1270; break;     /* fdup --> fmov.  */
25587     case 1770: value = 1272; break;     /* orr --> mov.  */
25588     case 1771: value = 2061; break;     /* orr --> orn.  */
25589     case 1773: value = 1275; break;     /* orr --> mov.  */
25590     case 1774: value = 1285; break;     /* orrs --> movs.  */
25591     case 1836: value = 1280; break;     /* sel --> mov.  */
25592     case 1837: value = 1283; break;     /* sel --> mov.  */
25593     default: return NULL;
25594     }
25595
25596   return aarch64_opcode_table + value;
25597 }
25598
25599 const aarch64_opcode *
25600 aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)
25601 {
25602   /* Use the index as the key to locate the next opcode.  */
25603   int key = opcode - aarch64_opcode_table;
25604   int value;
25605   switch (key)
25606     {
25607     case 3: value = 2; break;   /* ngc --> sbc.  */
25608     case 5: value = 4; break;   /* ngcs --> sbcs.  */
25609     case 8: value = 7; break;   /* cmn --> adds.  */
25610     case 11: value = 10; break; /* cmp --> subs.  */
25611     case 13: value = 12; break; /* mov --> add.  */
25612     case 15: value = 14; break; /* cmn --> adds.  */
25613     case 18: value = 17; break; /* cmp --> subs.  */
25614     case 23: value = 22; break; /* cmn --> adds.  */
25615     case 25: value = 24; break; /* neg --> sub.  */
25616     case 27: value = 28; break; /* cmp --> negs.  */
25617     case 28: value = 26; break; /* negs --> subs.  */
25618     case 153: value = 152; break;       /* mov --> umov.  */
25619     case 155: value = 154; break;       /* mov --> ins.  */
25620     case 157: value = 156; break;       /* mov --> ins.  */
25621     case 243: value = 242; break;       /* mvn --> not.  */
25622     case 318: value = 317; break;       /* mov --> orr.  */
25623     case 389: value = 388; break;       /* sxtl --> sshll.  */
25624     case 391: value = 390; break;       /* sxtl2 --> sshll2.  */
25625     case 413: value = 412; break;       /* uxtl --> ushll.  */
25626     case 415: value = 414; break;       /* uxtl2 --> ushll2.  */
25627     case 536: value = 535; break;       /* mov --> dup.  */
25628     case 623: value = 622; break;       /* sxtw --> sxth.  */
25629     case 622: value = 621; break;       /* sxth --> sxtb.  */
25630     case 621: value = 624; break;       /* sxtb --> asr.  */
25631     case 624: value = 620; break;       /* asr --> sbfx.  */
25632     case 620: value = 619; break;       /* sbfx --> sbfiz.  */
25633     case 619: value = 618; break;       /* sbfiz --> sbfm.  */
25634     case 627: value = 628; break;       /* bfc --> bfxil.  */
25635     case 628: value = 626; break;       /* bfxil --> bfi.  */
25636     case 626: value = 625; break;       /* bfi --> bfm.  */
25637     case 633: value = 632; break;       /* uxth --> uxtb.  */
25638     case 632: value = 635; break;       /* uxtb --> lsr.  */
25639     case 635: value = 634; break;       /* lsr --> lsl.  */
25640     case 634: value = 631; break;       /* lsl --> ubfx.  */
25641     case 631: value = 630; break;       /* ubfx --> ubfiz.  */
25642     case 630: value = 629; break;       /* ubfiz --> ubfm.  */
25643     case 665: value = 664; break;       /* cset --> cinc.  */
25644     case 664: value = 663; break;       /* cinc --> csinc.  */
25645     case 668: value = 667; break;       /* csetm --> cinv.  */
25646     case 667: value = 666; break;       /* cinv --> csinv.  */
25647     case 670: value = 669; break;       /* cneg --> csneg.  */
25648     case 688: value = 689; break;       /* rev --> rev64.  */
25649     case 714: value = 713; break;       /* lsl --> lslv.  */
25650     case 716: value = 715; break;       /* lsr --> lsrv.  */
25651     case 718: value = 717; break;       /* asr --> asrv.  */
25652     case 720: value = 719; break;       /* ror --> rorv.  */
25653     case 723: value = 722; break;       /* cmpp --> subps.  */
25654     case 736: value = 735; break;       /* mul --> madd.  */
25655     case 738: value = 737; break;       /* mneg --> msub.  */
25656     case 740: value = 739; break;       /* smull --> smaddl.  */
25657     case 742: value = 741; break;       /* smnegl --> smsubl.  */
25658     case 745: value = 744; break;       /* umull --> umaddl.  */
25659     case 747: value = 746; break;       /* umnegl --> umsubl.  */
25660     case 759: value = 758; break;       /* ror --> extr.  */
25661     case 996: value = 995; break;       /* bic --> and.  */
25662     case 998: value = 997; break;       /* mov --> orr.  */
25663     case 1001: value = 1000; break;     /* tst --> ands.  */
25664     case 1006: value = 1005; break;     /* uxtw --> mov.  */
25665     case 1005: value = 1004; break;     /* mov --> orr.  */
25666     case 1008: value = 1007; break;     /* mvn --> orn.  */
25667     case 1012: value = 1011; break;     /* tst --> ands.  */
25668     case 1138: value = 1042; break;     /* staddb --> ldaddb.  */
25669     case 1139: value = 1043; break;     /* staddh --> ldaddh.  */
25670     case 1140: value = 1044; break;     /* stadd --> ldadd.  */
25671     case 1141: value = 1046; break;     /* staddlb --> ldaddlb.  */
25672     case 1142: value = 1049; break;     /* staddlh --> ldaddlh.  */
25673     case 1143: value = 1052; break;     /* staddl --> ldaddl.  */
25674     case 1144: value = 1054; break;     /* stclrb --> ldclrb.  */
25675     case 1145: value = 1055; break;     /* stclrh --> ldclrh.  */
25676     case 1146: value = 1056; break;     /* stclr --> ldclr.  */
25677     case 1147: value = 1058; break;     /* stclrlb --> ldclrlb.  */
25678     case 1148: value = 1061; break;     /* stclrlh --> ldclrlh.  */
25679     case 1149: value = 1064; break;     /* stclrl --> ldclrl.  */
25680     case 1150: value = 1066; break;     /* steorb --> ldeorb.  */
25681     case 1151: value = 1067; break;     /* steorh --> ldeorh.  */
25682     case 1152: value = 1068; break;     /* steor --> ldeor.  */
25683     case 1153: value = 1070; break;     /* steorlb --> ldeorlb.  */
25684     case 1154: value = 1073; break;     /* steorlh --> ldeorlh.  */
25685     case 1155: value = 1076; break;     /* steorl --> ldeorl.  */
25686     case 1156: value = 1078; break;     /* stsetb --> ldsetb.  */
25687     case 1157: value = 1079; break;     /* stseth --> ldseth.  */
25688     case 1158: value = 1080; break;     /* stset --> ldset.  */
25689     case 1159: value = 1082; break;     /* stsetlb --> ldsetlb.  */
25690     case 1160: value = 1085; break;     /* stsetlh --> ldsetlh.  */
25691     case 1161: value = 1088; break;     /* stsetl --> ldsetl.  */
25692     case 1162: value = 1090; break;     /* stsmaxb --> ldsmaxb.  */
25693     case 1163: value = 1091; break;     /* stsmaxh --> ldsmaxh.  */
25694     case 1164: value = 1092; break;     /* stsmax --> ldsmax.  */
25695     case 1165: value = 1094; break;     /* stsmaxlb --> ldsmaxlb.  */
25696     case 1166: value = 1097; break;     /* stsmaxlh --> ldsmaxlh.  */
25697     case 1167: value = 1100; break;     /* stsmaxl --> ldsmaxl.  */
25698     case 1168: value = 1102; break;     /* stsminb --> ldsminb.  */
25699     case 1169: value = 1103; break;     /* stsminh --> ldsminh.  */
25700     case 1170: value = 1104; break;     /* stsmin --> ldsmin.  */
25701     case 1171: value = 1106; break;     /* stsminlb --> ldsminlb.  */
25702     case 1172: value = 1109; break;     /* stsminlh --> ldsminlh.  */
25703     case 1173: value = 1112; break;     /* stsminl --> ldsminl.  */
25704     case 1174: value = 1114; break;     /* stumaxb --> ldumaxb.  */
25705     case 1175: value = 1115; break;     /* stumaxh --> ldumaxh.  */
25706     case 1176: value = 1116; break;     /* stumax --> ldumax.  */
25707     case 1177: value = 1118; break;     /* stumaxlb --> ldumaxlb.  */
25708     case 1178: value = 1121; break;     /* stumaxlh --> ldumaxlh.  */
25709     case 1179: value = 1124; break;     /* stumaxl --> ldumaxl.  */
25710     case 1180: value = 1126; break;     /* stuminb --> lduminb.  */
25711     case 1181: value = 1127; break;     /* stuminh --> lduminh.  */
25712     case 1182: value = 1128; break;     /* stumin --> ldumin.  */
25713     case 1183: value = 1130; break;     /* stuminlb --> lduminlb.  */
25714     case 1184: value = 1133; break;     /* stuminlh --> lduminlh.  */
25715     case 1185: value = 1136; break;     /* stuminl --> lduminl.  */
25716     case 1187: value = 1186; break;     /* mov --> movn.  */
25717     case 1189: value = 1188; break;     /* mov --> movz.  */
25718     case 1251: value = 1250; break;     /* autibsp --> autibz.  */
25719     case 1250: value = 1249; break;     /* autibz --> autiasp.  */
25720     case 1249: value = 1248; break;     /* autiasp --> autiaz.  */
25721     case 1248: value = 1247; break;     /* autiaz --> pacibsp.  */
25722     case 1247: value = 1246; break;     /* pacibsp --> pacibz.  */
25723     case 1246: value = 1245; break;     /* pacibz --> paciasp.  */
25724     case 1245: value = 1244; break;     /* paciasp --> paciaz.  */
25725     case 1244: value = 1220; break;     /* paciaz --> clearbhb.  */
25726     case 1220: value = 1219; break;     /* clearbhb --> tsb.  */
25727     case 1219: value = 1218; break;     /* tsb --> psb.  */
25728     case 1218: value = 1217; break;     /* psb --> esb.  */
25729     case 1217: value = 1216; break;     /* esb --> autib1716.  */
25730     case 1216: value = 1215; break;     /* autib1716 --> autia1716.  */
25731     case 1215: value = 1214; break;     /* autia1716 --> pacib1716.  */
25732     case 1214: value = 1213; break;     /* pacib1716 --> pacia1716.  */
25733     case 1213: value = 1212; break;     /* pacia1716 --> xpaclri.  */
25734     case 1212: value = 1210; break;     /* xpaclri --> sevl.  */
25735     case 1210: value = 1209; break;     /* sevl --> sev.  */
25736     case 1209: value = 1208; break;     /* sev --> wfi.  */
25737     case 1208: value = 1207; break;     /* wfi --> wfe.  */
25738     case 1207: value = 1206; break;     /* wfe --> yield.  */
25739     case 1206: value = 1205; break;     /* yield --> bti.  */
25740     case 1205: value = 1204; break;     /* bti --> csdb.  */
25741     case 1204: value = 1203; break;     /* csdb --> nop.  */
25742     case 1203: value = 1202; break;     /* nop --> hint.  */
25743     case 1226: value = 1225; break;     /* pssbb --> ssbb.  */
25744     case 1225: value = 1224; break;     /* ssbb --> dfb.  */
25745     case 1224: value = 1222; break;     /* dfb --> dsb.  */
25746     case 1239: value = 1238; break;     /* cpp --> dvp.  */
25747     case 1238: value = 1237; break;     /* dvp --> cfp.  */
25748     case 1237: value = 1234; break;     /* cfp --> tlbi.  */
25749     case 1234: value = 1233; break;     /* tlbi --> ic.  */
25750     case 1233: value = 1232; break;     /* ic --> dc.  */
25751     case 1232: value = 1231; break;     /* dc --> at.  */
25752     case 1231: value = 1230; break;     /* at --> sys.  */
25753     case 2049: value = 1299; break;     /* bic --> and.  */
25754     case 1282: value = 1301; break;     /* mov --> and.  */
25755     case 1286: value = 1302; break;     /* movs --> ands.  */
25756     case 2050: value = 1337; break;     /* cmple --> cmpge.  */
25757     case 2053: value = 1340; break;     /* cmplt --> cmpgt.  */
25758     case 2051: value = 1342; break;     /* cmplo --> cmphi.  */
25759     case 2052: value = 1345; break;     /* cmpls --> cmphs.  */
25760     case 1279: value = 1367; break;     /* mov --> cpy.  */
25761     case 1281: value = 1368; break;     /* mov --> cpy.  */
25762     case 2060: value = 1284; break;     /* fmov --> mov.  */
25763     case 1284: value = 1369; break;     /* mov --> cpy.  */
25764     case 1274: value = 1381; break;     /* mov --> dup.  */
25765     case 1276: value = 1273; break;     /* mov --> mov.  */
25766     case 1273: value = 1382; break;     /* mov --> dup.  */
25767     case 2059: value = 1278; break;     /* fmov --> mov.  */
25768     case 1278: value = 1383; break;     /* mov --> dup.  */
25769     case 1277: value = 1384; break;     /* mov --> dupm.  */
25770     case 2054: value = 1386; break;     /* eon --> eor.  */
25771     case 1287: value = 1388; break;     /* not --> eor.  */
25772     case 1288: value = 1389; break;     /* nots --> eors.  */
25773     case 2055: value = 1394; break;     /* facle --> facge.  */
25774     case 2056: value = 1395; break;     /* faclt --> facgt.  */
25775     case 2057: value = 1408; break;     /* fcmle --> fcmge.  */
25776     case 2058: value = 1410; break;     /* fcmlt --> fcmgt.  */
25777     case 1271: value = 1416; break;     /* fmov --> fcpy.  */
25778     case 1270: value = 1439; break;     /* fmov --> fdup.  */
25779     case 1272: value = 1770; break;     /* mov --> orr.  */
25780     case 2061: value = 1771; break;     /* orn --> orr.  */
25781     case 1275: value = 1773; break;     /* mov --> orr.  */
25782     case 1285: value = 1774; break;     /* movs --> orrs.  */
25783     case 1280: value = 1836; break;     /* mov --> sel.  */
25784     case 1283: value = 1837; break;     /* mov --> sel.  */
25785     default: return NULL;
25786     }
25787
25788   return aarch64_opcode_table + value;
25789 }
25790
25791 bool
25792 aarch64_extract_operand (const aarch64_operand *self,
25793                            aarch64_opnd_info *info,
25794                            aarch64_insn code, const aarch64_inst *inst,
25795                            aarch64_operand_error *errors)
25796 {
25797   /* Use the index as the key.  */
25798   int key = self - aarch64_operands;
25799   switch (key)
25800     {
25801     case 1:
25802     case 2:
25803     case 3:
25804     case 4:
25805     case 5:
25806     case 6:
25807     case 7:
25808     case 8:
25809     case 9:
25810     case 11:
25811     case 12:
25812     case 13:
25813     case 17:
25814     case 18:
25815     case 19:
25816     case 20:
25817     case 22:
25818     case 23:
25819     case 24:
25820     case 25:
25821     case 26:
25822     case 27:
25823     case 28:
25824     case 29:
25825     case 30:
25826     case 31:
25827     case 167:
25828     case 168:
25829     case 169:
25830     case 170:
25831     case 171:
25832     case 172:
25833     case 173:
25834     case 174:
25835     case 175:
25836     case 176:
25837     case 191:
25838     case 192:
25839     case 193:
25840     case 194:
25841     case 195:
25842     case 196:
25843     case 197:
25844     case 198:
25845     case 199:
25846     case 205:
25847     case 208:
25848     case 210:
25849     case 211:
25850     case 214:
25851       return aarch64_ext_regno (self, info, code, inst, errors);
25852     case 10:
25853       return aarch64_ext_regrt_sysins (self, info, code, inst, errors);
25854     case 14:
25855       return aarch64_ext_regno_pair (self, info, code, inst, errors);
25856     case 15:
25857       return aarch64_ext_reg_extended (self, info, code, inst, errors);
25858     case 16:
25859       return aarch64_ext_reg_shifted (self, info, code, inst, errors);
25860     case 21:
25861       return aarch64_ext_ft (self, info, code, inst, errors);
25862     case 32:
25863     case 33:
25864     case 34:
25865     case 35:
25866     case 222:
25867       return aarch64_ext_reglane (self, info, code, inst, errors);
25868     case 36:
25869       return aarch64_ext_reglist (self, info, code, inst, errors);
25870     case 37:
25871       return aarch64_ext_ldst_reglist (self, info, code, inst, errors);
25872     case 38:
25873       return aarch64_ext_ldst_reglist_r (self, info, code, inst, errors);
25874     case 39:
25875       return aarch64_ext_ldst_elemlist (self, info, code, inst, errors);
25876     case 40:
25877     case 41:
25878     case 42:
25879     case 43:
25880     case 53:
25881     case 54:
25882     case 55:
25883     case 56:
25884     case 57:
25885     case 58:
25886     case 59:
25887     case 60:
25888     case 61:
25889     case 62:
25890     case 63:
25891     case 64:
25892     case 65:
25893     case 66:
25894     case 67:
25895     case 68:
25896     case 69:
25897     case 80:
25898     case 81:
25899     case 82:
25900     case 83:
25901     case 84:
25902     case 164:
25903     case 166:
25904     case 183:
25905     case 184:
25906     case 185:
25907     case 186:
25908     case 187:
25909     case 188:
25910     case 189:
25911     case 190:
25912     case 215:
25913     case 221:
25914     case 226:
25915     case 227:
25916       return aarch64_ext_imm (self, info, code, inst, errors);
25917     case 44:
25918     case 45:
25919       return aarch64_ext_advsimd_imm_shift (self, info, code, inst, errors);
25920     case 46:
25921     case 47:
25922     case 48:
25923       return aarch64_ext_advsimd_imm_modified (self, info, code, inst, errors);
25924     case 49:
25925       return aarch64_ext_shll_imm (self, info, code, inst, errors);
25926     case 52:
25927     case 154:
25928       return aarch64_ext_fpimm (self, info, code, inst, errors);
25929     case 70:
25930     case 162:
25931       return aarch64_ext_limm (self, info, code, inst, errors);
25932     case 71:
25933       return aarch64_ext_aimm (self, info, code, inst, errors);
25934     case 72:
25935       return aarch64_ext_imm_half (self, info, code, inst, errors);
25936     case 73:
25937       return aarch64_ext_fbits (self, info, code, inst, errors);
25938     case 75:
25939     case 76:
25940     case 159:
25941       return aarch64_ext_imm_rotate2 (self, info, code, inst, errors);
25942     case 77:
25943     case 158:
25944     case 160:
25945       return aarch64_ext_imm_rotate1 (self, info, code, inst, errors);
25946     case 78:
25947     case 79:
25948       return aarch64_ext_cond (self, info, code, inst, errors);
25949     case 85:
25950     case 94:
25951       return aarch64_ext_addr_simple (self, info, code, inst, errors);
25952     case 86:
25953       return aarch64_ext_addr_regoff (self, info, code, inst, errors);
25954     case 87:
25955     case 88:
25956     case 89:
25957     case 91:
25958     case 93:
25959       return aarch64_ext_addr_simm (self, info, code, inst, errors);
25960     case 90:
25961       return aarch64_ext_addr_simm10 (self, info, code, inst, errors);
25962     case 92:
25963       return aarch64_ext_addr_uimm12 (self, info, code, inst, errors);
25964     case 95:
25965       return aarch64_ext_addr_offset (self, info, code, inst, errors);
25966     case 96:
25967       return aarch64_ext_simd_addr_post (self, info, code, inst, errors);
25968     case 97:
25969       return aarch64_ext_sysreg (self, info, code, inst, errors);
25970     case 98:
25971       return aarch64_ext_pstatefield (self, info, code, inst, errors);
25972     case 99:
25973     case 100:
25974     case 101:
25975     case 102:
25976     case 103:
25977       return aarch64_ext_sysins_op (self, info, code, inst, errors);
25978     case 104:
25979     case 106:
25980       return aarch64_ext_barrier (self, info, code, inst, errors);
25981     case 105:
25982       return aarch64_ext_barrier_dsb_nxs (self, info, code, inst, errors);
25983     case 107:
25984       return aarch64_ext_prfop (self, info, code, inst, errors);
25985     case 108:
25986       return aarch64_ext_none (self, info, code, inst, errors);
25987     case 109:
25988       return aarch64_ext_hint (self, info, code, inst, errors);
25989     case 110:
25990     case 111:
25991       return aarch64_ext_sve_addr_ri_s4 (self, info, code, inst, errors);
25992     case 112:
25993     case 113:
25994     case 114:
25995     case 115:
25996       return aarch64_ext_sve_addr_ri_s4xvl (self, info, code, inst, errors);
25997     case 116:
25998       return aarch64_ext_sve_addr_ri_s6xvl (self, info, code, inst, errors);
25999     case 117:
26000       return aarch64_ext_sve_addr_ri_s9xvl (self, info, code, inst, errors);
26001     case 118:
26002     case 119:
26003     case 120:
26004     case 121:
26005       return aarch64_ext_sve_addr_ri_u6 (self, info, code, inst, errors);
26006     case 122:
26007     case 123:
26008     case 124:
26009     case 125:
26010     case 126:
26011     case 127:
26012     case 128:
26013     case 129:
26014     case 130:
26015     case 131:
26016     case 132:
26017     case 133:
26018     case 134:
26019     case 135:
26020     case 136:
26021       return aarch64_ext_sve_addr_rr_lsl (self, info, code, inst, errors);
26022     case 137:
26023     case 138:
26024     case 139:
26025     case 140:
26026     case 141:
26027     case 142:
26028     case 143:
26029     case 144:
26030       return aarch64_ext_sve_addr_rz_xtw (self, info, code, inst, errors);
26031     case 145:
26032     case 146:
26033     case 147:
26034     case 148:
26035       return aarch64_ext_sve_addr_zi_u5 (self, info, code, inst, errors);
26036     case 149:
26037       return aarch64_ext_sve_addr_zz_lsl (self, info, code, inst, errors);
26038     case 150:
26039       return aarch64_ext_sve_addr_zz_sxtw (self, info, code, inst, errors);
26040     case 151:
26041       return aarch64_ext_sve_addr_zz_uxtw (self, info, code, inst, errors);
26042     case 152:
26043       return aarch64_ext_sve_aimm (self, info, code, inst, errors);
26044     case 153:
26045       return aarch64_ext_sve_asimm (self, info, code, inst, errors);
26046     case 155:
26047       return aarch64_ext_sve_float_half_one (self, info, code, inst, errors);
26048     case 156:
26049       return aarch64_ext_sve_float_half_two (self, info, code, inst, errors);
26050     case 157:
26051       return aarch64_ext_sve_float_zero_one (self, info, code, inst, errors);
26052     case 161:
26053       return aarch64_ext_inv_limm (self, info, code, inst, errors);
26054     case 163:
26055       return aarch64_ext_sve_limm_mov (self, info, code, inst, errors);
26056     case 165:
26057       return aarch64_ext_sve_scale (self, info, code, inst, errors);
26058     case 177:
26059     case 178:
26060     case 179:
26061       return aarch64_ext_sve_shlimm (self, info, code, inst, errors);
26062     case 180:
26063     case 181:
26064     case 182:
26065       return aarch64_ext_sve_shrimm (self, info, code, inst, errors);
26066     case 200:
26067     case 201:
26068     case 202:
26069     case 203:
26070     case 204:
26071       return aarch64_ext_sve_quad_index (self, info, code, inst, errors);
26072     case 206:
26073       return aarch64_ext_sve_index (self, info, code, inst, errors);
26074     case 207:
26075     case 209:
26076       return aarch64_ext_sve_reglist (self, info, code, inst, errors);
26077     case 212:
26078     case 213:
26079     case 216:
26080       return aarch64_ext_sme_za_hv_tiles (self, info, code, inst, errors);
26081     case 217:
26082       return aarch64_ext_sme_za_array (self, info, code, inst, errors);
26083     case 218:
26084       return aarch64_ext_sme_addr_ri_u4xvl (self, info, code, inst, errors);
26085     case 219:
26086       return aarch64_ext_sme_sm_za (self, info, code, inst, errors);
26087     case 220:
26088       return aarch64_ext_sme_pred_reg_with_index (self, info, code, inst, errors);
26089     case 223:
26090     case 224:
26091     case 225:
26092       return aarch64_ext_x0_to_x30 (self, info, code, inst, errors);
26093     default: assert (0); abort ();
26094     }
26095 }