opcodes/aarch64-dis-2.c

   1 /* This file is automatically generated by aarch64-gen.  Do not edit!  */
   2 /* Copyright (C) 2012-2021 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 2358;
  64                                             }
  65                                           else
  66                                             {
  67                                               /* 33222222222211111111110000000000
  68                                                  10987654321098765432109876543210
  69                                                  x0000000100xxxxxxxxxxxxxxxx1xxxx
  70                                                  fmops.  */
  71                                               return 2361;
  72                                             }
  73                                         }
  74                                     }
  75                                   else
  76                                     {
  77                                       if (((word >> 4) & 0x1) == 0)
  78                                         {
  79                                           /* 33222222222211111111110000000000
  80                                              10987654321098765432109876543210
  81                                              x0000000x10xxxxxxxxxxxxxxxx0xxxx
  82                                              fmopa.  */
  83                                           return 2359;
  84                                         }
  85                                       else
  86                                         {
  87                                           /* 33222222222211111111110000000000
  88                                              10987654321098765432109876543210
  89                                              x0000000x10xxxxxxxxxxxxxxxx1xxxx
  90                                              fmops.  */
  91                                           return 2362;
  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 2381;
 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 2352;
 120                                                     }
 121                                                   else
 122                                                     {
 123                                                       /* 33222222222211111111110000000000
 124                                                          10987654321098765432109876543210
 125                                                          x1000000x1010x00xxxxxxxxxxxxxxxx
 126                                                          addha.  */
 127                                                       return 2353;
 128                                                     }
 129                                                 }
 130                                               else
 131                                                 {
 132                                                   if (((word >> 22) & 0x1) == 0)
 133                                                     {
 134                                                       /* 33222222222211111111110000000000
 135                                                          10987654321098765432109876543210
 136                                                          x1000000x0010x01xxxxxxxxxxxxxxxx
 137                                                          addva.  */
 138                                                       return 2354;
 139                                                     }
 140                                                   else
 141                                                     {
 142                                                       /* 33222222222211111111110000000000
 143                                                          10987654321098765432109876543210
 144                                                          x1000000x1010x01xxxxxxxxxxxxxxxx
 145                                                          addva.  */
 146                                                       return 2355;
 147                                                     }
 148                                                 }
 149                                             }
 150                                         }
 151                                       else
 152                                         {
 153                                           /* 33222222222211111111110000000000
 154                                              10987654321098765432109876543210
 155                                              x1000000xx0x1x0xxxxxxxxxxxxxxxxx
 156                                              zero.  */
 157                                           return 2384;
 158                                         }
 159                                     }
 160                                   else
 161                                     {
 162                                       /* 33222222222211111111110000000000
 163                                          10987654321098765432109876543210
 164                                          x1000000xx0xxx1xxxxxxxxxxxxxxxxx
 165                                          mov.  */
 166                                       return 2380;
 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 2385;
 183                                         }
 184                                       else
 185                                         {
 186                                           if (((word >> 30) & 0x1) == 0)
 187                                             {
 188                                               /* 33222222222211111111110000000000
 189                                                  10987654321098765432109876543210
 190                                                  x0100000100xxxxxxxxxxxxxxxx0xxxx
 191                                                  smopa.  */
 192                                               return 2364;
 193                                             }
 194                                           else
 195                                             {
 196                                               /* 33222222222211111111110000000000
 197                                                  10987654321098765432109876543210
 198                                                  x1100000100xxxxxxxxxxxxxxxx0xxxx
 199                                                  ld1w.  */
 200                                               return 2387;
 201                                             }
 202                                         }
 203                                     }
 204                                   else
 205                                     {
 206                                       if (((word >> 23) & 0x1) == 0)
 207                                         {
 208                                           /* 33222222222211111111110000000000
 209                                              10987654321098765432109876543210
 210                                              xx100000010xxxxxxxxxxxxxxxx0xxxx
 211                                              ld1h.  */
 212                                           return 2386;
 213                                         }
 214                                       else
 215                                         {
 216                                           if (((word >> 30) & 0x1) == 0)
 217                                             {
 218                                               /* 33222222222211111111110000000000
 219                                                  10987654321098765432109876543210
 220                                                  x0100000110xxxxxxxxxxxxxxxx0xxxx
 221                                                  smopa.  */
 222                                               return 2365;
 223                                             }
 224                                           else
 225                                             {
 226                                               /* 33222222222211111111110000000000
 227                                                  10987654321098765432109876543210
 228                                                  x1100000110xxxxxxxxxxxxxxxx0xxxx
 229                                                  ld1d.  */
 230                                               return 2388;
 231                                             }
 232                                         }
 233                                     }
 234                                 }
 235                               else
 236                                 {
 237                                   if (((word >> 22) & 0x1) == 0)
 238                                     {
 239                                       /* 33222222222211111111110000000000
 240                                          10987654321098765432109876543210
 241                                          xx100000x00xxxxxxxxxxxxxxxx1xxxx
 242                                          smops.  */
 243                                       return 2366;
 244                                     }
 245                                   else
 246                                     {
 247                                       /* 33222222222211111111110000000000
 248                                          10987654321098765432109876543210
 249                                          xx100000x10xxxxxxxxxxxxxxxx1xxxx
 250                                          smops.  */
 251                                       return 2367;
 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 2395;
 269                                     }
 270                                   else
 271                                     {
 272                                       if (((word >> 30) & 0x1) == 0)
 273                                         {
 274                                           /* 33222222222211111111110000000000
 275                                              10987654321098765432109876543210
 276                                              x0x00000101xxxxxxxxxxxxxxxx0xxxx
 277                                              sumopa.  */
 278                                           return 2368;
 279                                         }
 280                                       else
 281                                         {
 282                                           /* 33222222222211111111110000000000
 283                                              10987654321098765432109876543210
 284                                              x1x00000101xxxxxxxxxxxxxxxx0xxxx
 285                                              st1w.  */
 286                                           return 2397;
 287                                         }
 288                                     }
 289                                 }
 290                               else
 291                                 {
 292                                   if (((word >> 23) & 0x1) == 0)
 293                                     {
 294                                       /* 33222222222211111111110000000000
 295                                          10987654321098765432109876543210
 296                                          xxx00000011xxxxxxxxxxxxxxxx0xxxx
 297                                          st1h.  */
 298                                       return 2396;
 299                                     }
 300                                   else
 301                                     {
 302                                       if (((word >> 30) & 0x1) == 0)
 303                                         {
 304                                           /* 33222222222211111111110000000000
 305                                              10987654321098765432109876543210
 306                                              x0x00000111xxxxxxxxxxxxxxxx0xxxx
 307                                              sumopa.  */
 308                                           return 2369;
 309                                         }
 310                                       else
 311                                         {
 312                                           /* 33222222222211111111110000000000
 313                                              10987654321098765432109876543210
 314                                              x1x00000111xxxxxxxxxxxxxxxx0xxxx
 315                                              st1d.  */
 316                                           return 2398;
 317                                         }
 318                                     }
 319                                 }
 320                             }
 321                           else
 322                             {
 323                               if (((word >> 22) & 0x1) == 0)
 324                                 {
 325                                   /* 33222222222211111111110000000000
 326                                      10987654321098765432109876543210
 327                                      xxx00000x01xxxxxxxxxxxxxxxx1xxxx
 328                                      sumops.  */
 329                                   return 2370;
 330                                 }
 331                               else
 332                                 {
 333                                   /* 33222222222211111111110000000000
 334                                      10987654321098765432109876543210
 335                                      xxx00000x11xxxxxxxxxxxxxxxx1xxxx
 336                                      sumops.  */
 337                                   return 2371;
 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 2405;
 379                                     }
 380                                   else
 381                                     {
 382                                       if (((word >> 29) & 0x1) == 0)
 383                                         {
 384                                           /* 33222222222211111111110000000000
 385                                              10987654321098765432109876543210
 386                                              xx000001100xxxxxxxxxxxxxxxx0xxxx
 387                                              bfmopa.  */
 388                                           return 2356;
 389                                         }
 390                                       else
 391                                         {
 392                                           /* 33222222222211111111110000000000
 393                                              10987654321098765432109876543210
 394                                              xx100001100xxxxxxxxxxxxxxxx0xxxx
 395                                              usmopa.  */
 396                                           return 2376;
 397                                         }
 398                                     }
 399                                 }
 400                               else
 401                                 {
 402                                   if (((word >> 30) & 0x1) == 0)
 403                                     {
 404                                       /* 33222222222211111111110000000000
 405                                          10987654321098765432109876543210
 406                                          x0x00001x10xxxxxxxxxxxxxxxx0xxxx
 407                                          usmopa.  */
 408                                       return 2377;
 409                                     }
 410                                   else
 411                                     {
 412                                       /* 33222222222211111111110000000000
 413                                          10987654321098765432109876543210
 414                                          x1x00001x10xxxxxxxxxxxxxxxx0xxxx
 415                                          ld1q.  */
 416                                       return 2389;
 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 2406;
 431                                     }
 432                                   else
 433                                     {
 434                                       if (((word >> 29) & 0x1) == 0)
 435                                         {
 436                                           /* 33222222222211111111110000000000
 437                                              10987654321098765432109876543210
 438                                              xx000001101xxxxxxxxxxxxxxxx0xxxx
 439                                              fmopa.  */
 440                                           return 2360;
 441                                         }
 442                                       else
 443                                         {
 444                                           /* 33222222222211111111110000000000
 445                                              10987654321098765432109876543210
 446                                              xx100001101xxxxxxxxxxxxxxxx0xxxx
 447                                              umopa.  */
 448                                           return 2372;
 449                                         }
 450                                     }
 451                                 }
 452                               else
 453                                 {
 454                                   if (((word >> 30) & 0x1) == 0)
 455                                     {
 456                                       /* 33222222222211111111110000000000
 457                                          10987654321098765432109876543210
 458                                          x0x00001x11xxxxxxxxxxxxxxxx0xxxx
 459                                          umopa.  */
 460                                       return 2373;
 461                                     }
 462                                   else
 463                                     {
 464                                       /* 33222222222211111111110000000000
 465                                          10987654321098765432109876543210
 466                                          x1x00001x11xxxxxxxxxxxxxxxx0xxxx
 467                                          st1q.  */
 468                                       return 2399;
 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 2357;
 486                                     }
 487                                   else
 488                                     {
 489                                       /* 33222222222211111111110000000000
 490                                          10987654321098765432109876543210
 491                                          xx100001x00xxxxxxxxxxxxxxxx1xxxx
 492                                          usmops.  */
 493                                       return 2378;
 494                                     }
 495                                 }
 496                               else
 497                                 {
 498                                   /* 33222222222211111111110000000000
 499                                      10987654321098765432109876543210
 500                                      xxx00001x10xxxxxxxxxxxxxxxx1xxxx
 501                                      usmops.  */
 502                                   return 2379;
 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 2363;
 516                                     }
 517                                   else
 518                                     {
 519                                       /* 33222222222211111111110000000000
 520                                          10987654321098765432109876543210
 521                                          xx100001x01xxxxxxxxxxxxxxxx1xxxx
 522                                          umops.  */
 523                                       return 2374;
 524                                     }
 525                                 }
 526                               else
 527                                 {
 528                                   /* 33222222222211111111110000000000
 529                                      10987654321098765432109876543210
 530                                      xxx00001x11xxxxxxxxxxxxxxxx1xxxx
 531                                      umops.  */
 532                                   return 2375;
 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 2451;
2900                                                     }
2901                                                   else
2902                                                     {
2903                                                       /* 33222222222211111111110000000000
2904                                                          10987654321098765432109876543210
2905                                                          10011001000xxxxxxxxx00xxxxxxxxxx
2906                                                          stlur.  */
2907                                                       return 2459;
2908                                                     }
2909                                                 }
2910                                               else
2911                                                 {
2912                                                   if (((word >> 31) & 0x1) == 0)
2913                                                     {
2914                                                       /* 33222222222211111111110000000000
2915                                                          10987654321098765432109876543210
2916                                                          01011001000xxxxxxxxx00xxxxxxxxxx
2917                                                          stlurh.  */
2918                                                       return 2455;
2919                                                     }
2920                                                   else
2921                                                     {
2922                                                       /* 33222222222211111111110000000000
2923                                                          10987654321098765432109876543210
2924                                                          11011001000xxxxxxxxx00xxxxxxxxxx
2925                                                          stlur.  */
2926                                                       return 2462;
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                                       /* 33222222222211111111110000000000
2951                                          10987654321098765432109876543210
2952                                          xx01100100xxxxxxxxxxx1xxxxxxxxxx
2953                                          stg.  */
2954                                       return 885;
2955                                     }
2956                                 }
2957                               else
2958                                 {
2959                                   if (((word >> 31) & 0x1) == 0)
2960                                     {
2961                                       if (((word >> 30) & 0x1) == 0)
2962                                         {
2963                                           /* 33222222222211111111110000000000
2964                                              10987654321098765432109876543210
2965                                              0011100100xxxxxxxxxxxxxxxxxxxxxx
2966                                              strb.  */
2967                                           return 889;
2968                                         }
2969                                       else
2970                                         {
2971                                           /* 33222222222211111111110000000000
2972                                              10987654321098765432109876543210
2973                                              0111100100xxxxxxxxxxxxxxxxxxxxxx
2974                                              strh.  */
2975                                           return 894;
2976                                         }
2977                                     }
2978                                   else
2979                                     {
2980                                       /* 33222222222211111111110000000000
2981                                          10987654321098765432109876543210
2982                                          1x11100100xxxxxxxxxxxxxxxxxxxxxx
2983                                          str.  */
2984                                       return 897;
2985                                     }
2986                                 }
2987                             }
2988                           else
2989                             {
2990                               if (((word >> 29) & 0x1) == 0)
2991                                 {
2992                                   if (((word >> 10) & 0x1) == 0)
2993                                     {
2994                                       if (((word >> 11) & 0x1) == 0)
2995                                         {
2996                                           if (((word >> 21) & 0x1) == 0)
2997                                             {
2998                                               if (((word >> 30) & 0x1) == 0)
2999                                                 {
3000                                                   if (((word >> 31) & 0x1) == 0)
3001                                                     {
3002                                                       /* 33222222222211111111110000000000
3003                                                          10987654321098765432109876543210
3004                                                          00011001010xxxxxxxxx00xxxxxxxxxx
3005                                                          ldapurb.  */
3006                                                       return 2452;
3007                                                     }
3008                                                   else
3009                                                     {
3010                                                       /* 33222222222211111111110000000000
3011                                                          10987654321098765432109876543210
3012                                                          10011001010xxxxxxxxx00xxxxxxxxxx
3013                                                          ldapur.  */
3014                                                       return 2460;
3015                                                     }
3016                                                 }
3017                                               else
3018                                                 {
3019                                                   if (((word >> 31) & 0x1) == 0)
3020                                                     {
3021                                                       /* 33222222222211111111110000000000
3022                                                          10987654321098765432109876543210
3023                                                          01011001010xxxxxxxxx00xxxxxxxxxx
3024                                                          ldapurh.  */
3025                                                       return 2456;
3026                                                     }
3027                                                   else
3028                                                     {
3029                                                       /* 33222222222211111111110000000000
3030                                                          10987654321098765432109876543210
3031                                                          11011001010xxxxxxxxx00xxxxxxxxxx
3032                                                          ldapur.  */
3033                                                       return 2463;
3034                                                     }
3035                                                 }
3036                                             }
3037                                           else
3038                                             {
3039                                               /* 33222222222211111111110000000000
3040                                                  10987654321098765432109876543210
3041                                                  xx011001011xxxxxxxxx00xxxxxxxxxx
3042                                                  ldg.  */
3043                                               return 934;
3044                                             }
3045                                         }
3046                                       else
3047                                         {
3048                                           /* 33222222222211111111110000000000
3049                                              10987654321098765432109876543210
3050                                              xx01100101xxxxxxxxxx10xxxxxxxxxx
3051                                              stzg.  */
3052                                           return 882;
3053                                         }
3054                                     }
3055                                   else
3056                                     {
3057                                       /* 33222222222211111111110000000000
3058                                          10987654321098765432109876543210
3059                                          xx01100101xxxxxxxxxxx1xxxxxxxxxx
3060                                          stzg.  */
3061                                       return 886;
3062                                     }
3063                                 }
3064                               else
3065                                 {
3066                                   if (((word >> 31) & 0x1) == 0)
3067                                     {
3068                                       if (((word >> 30) & 0x1) == 0)
3069                                         {
3070                                           /* 33222222222211111111110000000000
3071                                              10987654321098765432109876543210
3072                                              0011100101xxxxxxxxxxxxxxxxxxxxxx
3073                                              ldrb.  */
3074                                           return 890;
3075                                         }
3076                                       else
3077                                         {
3078                                           /* 33222222222211111111110000000000
3079                                              10987654321098765432109876543210
3080                                              0111100101xxxxxxxxxxxxxxxxxxxxxx
3081                                              ldrh.  */
3082                                           return 895;
3083                                         }
3084                                     }
3085                                   else
3086                                     {
3087                                       /* 33222222222211111111110000000000
3088                                          10987654321098765432109876543210
3089                                          1x11100101xxxxxxxxxxxxxxxxxxxxxx
3090                                          ldr.  */
3091                                       return 898;
3092                                     }
3093                                 }
3094                             }
3095                         }
3096                       else
3097                         {
3098                           if (((word >> 29) & 0x1) == 0)
3099                             {
3100                               if (((word >> 10) & 0x1) == 0)
3101                                 {
3102                                   if (((word >> 11) & 0x1) == 0)
3103                                     {
3104                                       if (((word >> 21) & 0x1) == 0)
3105                                         {
3106                                           if (((word >> 22) & 0x1) == 0)
3107                                             {
3108                                               if (((word >> 30) & 0x1) == 0)
3109                                                 {
3110                                                   if (((word >> 31) & 0x1) == 0)
3111                                                     {
3112                                                       /* 33222222222211111111110000000000
3113                                                          10987654321098765432109876543210
3114                                                          00011001100xxxxxxxxx00xxxxxxxxxx
3115                                                          ldapursb.  */
3116                                                       return 2454;
3117                                                     }
3118                                                   else
3119                                                     {
3120                                                       /* 33222222222211111111110000000000
3121                                                          10987654321098765432109876543210
3122                                                          10011001100xxxxxxxxx00xxxxxxxxxx
3123                                                          ldapursw.  */
3124                                                       return 2461;
3125                                                     }
3126                                                 }
3127                                               else
3128                                                 {
3129                                                   /* 33222222222211111111110000000000
3130                                                      10987654321098765432109876543210
3131                                                      x1011001100xxxxxxxxx00xxxxxxxxxx
3132                                                      ldapursh.  */
3133                                                   return 2458;
3134                                                 }
3135                                             }
3136                                           else
3137                                             {
3138                                               if (((word >> 30) & 0x1) == 0)
3139                                                 {
3140                                                   /* 33222222222211111111110000000000
3141                                                      10987654321098765432109876543210
3142                                                      x0011001110xxxxxxxxx00xxxxxxxxxx
3143                                                      ldapursb.  */
3144                                                   return 2453;
3145                                                 }
3146                                               else
3147                                                 {
3148                                                   /* 33222222222211111111110000000000
3149                                                      10987654321098765432109876543210
3150                                                      x1011001110xxxxxxxxx00xxxxxxxxxx
3151                                                      ldapursh.  */
3152                                                   return 2457;
3153                                                 }
3154                                             }
3155                                         }
3156                                       else
3157                                         {
3158                                           if (((word >> 22) & 0x1) == 0)
3159                                             {
3160                                               /* 33222222222211111111110000000000
3161                                                  10987654321098765432109876543210
3162                                                  xx011001101xxxxxxxxx00xxxxxxxxxx
3163                                                  stgm.  */
3164                                               return 963;
3165                                             }
3166                                           else
3167                                             {
3168                                               /* 33222222222211111111110000000000
3169                                                  10987654321098765432109876543210
3170                                                  xx011001111xxxxxxxxx00xxxxxxxxxx
3171                                                  ldgm.  */
3172                                               return 962;
3173                                             }
3174                                         }
3175                                     }
3176                                   else
3177                                     {
3178                                       if (((word >> 22) & 0x1) == 0)
3179                                         {
3180                                           /* 33222222222211111111110000000000
3181                                              10987654321098765432109876543210
3182                                              xx01100110xxxxxxxxxx10xxxxxxxxxx
3183                                              st2g.  */
3184                                           return 883;
3185                                         }
3186                                       else
3187                                         {
3188                                           /* 33222222222211111111110000000000
3189                                              10987654321098765432109876543210
3190                                              xx01100111xxxxxxxxxx10xxxxxxxxxx
3191                                              stz2g.  */
3192                                           return 884;
3193                                         }
3194                                     }
3195                                 }
3196                               else
3197                                 {
3198                                   if (((word >> 22) & 0x1) == 0)
3199                                     {
3200                                       /* 33222222222211111111110000000000
3201                                          10987654321098765432109876543210
3202                                          xx01100110xxxxxxxxxxx1xxxxxxxxxx
3203                                          st2g.  */
3204                                       return 887;
3205                                     }
3206                                   else
3207                                     {
3208                                       /* 33222222222211111111110000000000
3209                                          10987654321098765432109876543210
3210                                          xx01100111xxxxxxxxxxx1xxxxxxxxxx
3211                                          stz2g.  */
3212                                       return 888;
3213                                     }
3214                                 }
3215                             }
3216                           else
3217                             {
3218                               if (((word >> 30) & 0x1) == 0)
3219                                 {
3220                                   if (((word >> 31) & 0x1) == 0)
3221                                     {
3222                                       /* 33222222222211111111110000000000
3223                                          10987654321098765432109876543210
3224                                          001110011xxxxxxxxxxxxxxxxxxxxxxx
3225                                          ldrsb.  */
3226                                       return 891;
3227                                     }
3228                                   else
3229                                     {
3230                                       /* 33222222222211111111110000000000
3231                                          10987654321098765432109876543210
3232                                          101110011xxxxxxxxxxxxxxxxxxxxxxx
3233                                          ldrsw.  */
3234                                       return 899;
3235                                     }
3236                                 }
3237                               else
3238                                 {
3239                                   if (((word >> 31) & 0x1) == 0)
3240                                     {
3241                                       /* 33222222222211111111110000000000
3242                                          10987654321098765432109876543210
3243                                          011110011xxxxxxxxxxxxxxxxxxxxxxx
3244                                          ldrsh.  */
3245                                       return 896;
3246                                     }
3247                                   else
3248                                     {
3249                                       /* 33222222222211111111110000000000
3250                                          10987654321098765432109876543210
3251                                          111110011xxxxxxxxxxxxxxxxxxxxxxx
3252                                          prfm.  */
3253                                       return 900;
3254                                     }
3255                                 }
3256                             }
3257                         }
3258                     }
3259                 }
3260             }
3261         }
3262       else
3263         {
3264           if (((word >> 24) & 0x1) == 0)
3265             {
3266               if (((word >> 27) & 0x1) == 0)
3267                 {
3268                   if (((word >> 23) & 0x1) == 0)
3269                     {
3270                       if (((word >> 29) & 0x1) == 0)
3271                         {
3272                           if (((word >> 30) & 0x1) == 0)
3273                             {
3274                               /* 33222222222211111111110000000000
3275                                  10987654321098765432109876543210
3276                                  x00x00100xxxxxxxxxxxxxxxxxxxxxxx
3277                                  and.  */
3278                               return 995;
3279                             }
3280                           else
3281                             {
3282                               /* 33222222222211111111110000000000
3283                                  10987654321098765432109876543210
3284                                  x10x00100xxxxxxxxxxxxxxxxxxxxxxx
3285                                  eor.  */
3286                               return 999;
3287                             }
3288                         }
3289                       else
3290                         {
3291                           if (((word >> 30) & 0x1) == 0)
3292                             {
3293                               /* 33222222222211111111110000000000
3294                                  10987654321098765432109876543210
3295                                  x01x00100xxxxxxxxxxxxxxxxxxxxxxx
3296                                  orr.  */
3297                               return 997;
3298                             }
3299                           else
3300                             {
3301                               /* 33222222222211111111110000000000
3302                                  10987654321098765432109876543210
3303                                  x11x00100xxxxxxxxxxxxxxxxxxxxxxx
3304                                  ands.  */
3305                               return 1000;
3306                             }
3307                         }
3308                     }
3309                   else
3310                     {
3311                       if (((word >> 29) & 0x1) == 0)
3312                         {
3313                           if (((word >> 30) & 0x1) == 0)
3314                             {
3315                               /* 33222222222211111111110000000000
3316                                  10987654321098765432109876543210
3317                                  x00x00101xxxxxxxxxxxxxxxxxxxxxxx
3318                                  movn.  */
3319                               return 1186;
3320                             }
3321                           else
3322                             {
3323                               /* 33222222222211111111110000000000
3324                                  10987654321098765432109876543210
3325                                  x10x00101xxxxxxxxxxxxxxxxxxxxxxx
3326                                  movz.  */
3327                               return 1188;
3328                             }
3329                         }
3330                       else
3331                         {
3332                           /* 33222222222211111111110000000000
3333                              10987654321098765432109876543210
3334                              xx1x00101xxxxxxxxxxxxxxxxxxxxxxx
3335                              movk.  */
3336                           return 1190;
3337                         }
3338                     }
3339                 }
3340               else
3341                 {
3342                   if (((word >> 21) & 0x1) == 0)
3343                     {
3344                       if (((word >> 28) & 0x1) == 0)
3345                         {
3346                           if (((word >> 29) & 0x1) == 0)
3347                             {
3348                               if (((word >> 30) & 0x1) == 0)
3349                                 {
3350                                   /* 33222222222211111111110000000000
3351                                      10987654321098765432109876543210
3352                                      x0001010xx0xxxxxxxxxxxxxxxxxxxxx
3353                                      and.  */
3354                                   return 1002;
3355                                 }
3356                               else
3357                                 {
3358                                   /* 33222222222211111111110000000000
3359                                      10987654321098765432109876543210
3360                                      x1001010xx0xxxxxxxxxxxxxxxxxxxxx
3361                                      eor.  */
3362                                   return 1009;
3363                                 }
3364                             }
3365                           else
3366                             {
3367                               if (((word >> 30) & 0x1) == 0)
3368                                 {
3369                                   /* 33222222222211111111110000000000
3370                                      10987654321098765432109876543210
3371                                      x0101010xx0xxxxxxxxxxxxxxxxxxxxx
3372                                      orr.  */
3373                                   return 1004;
3374                                 }
3375                               else
3376                                 {
3377                                   /* 33222222222211111111110000000000
3378                                      10987654321098765432109876543210
3379                                      x1101010xx0xxxxxxxxxxxxxxxxxxxxx
3380                                      ands.  */
3381                                   return 1011;
3382                                 }
3383                             }
3384                         }
3385                       else
3386                         {
3387                           if (((word >> 10) & 0x1) == 0)
3388                             {
3389                               if (((word >> 11) & 0x1) == 0)
3390                                 {
3391                                   if (((word >> 22) & 0x1) == 0)
3392                                     {
3393                                       if (((word >> 23) & 0x1) == 0)
3394                                         {
3395                                           if (((word >> 29) & 0x1) == 0)
3396                                             {
3397                                               if (((word >> 30) & 0x1) == 0)
3398                                                 {
3399                                                   /* 33222222222211111111110000000000
3400                                                      10987654321098765432109876543210
3401                                                      x0011010000xxxxxxxxx00xxxxxxxxxx
3402                                                      adc.  */
3403                                                   return 0;
3404                                                 }
3405                                               else
3406                                                 {
3407                                                   /* 33222222222211111111110000000000
3408                                                      10987654321098765432109876543210
3409                                                      x1011010000xxxxxxxxx00xxxxxxxxxx
3410                                                      sbc.  */
3411                                                   return 2;
3412                                                 }
3413                                             }
3414                                           else
3415                                             {
3416                                               if (((word >> 30) & 0x1) == 0)
3417                                                 {
3418                                                   /* 33222222222211111111110000000000
3419                                                      10987654321098765432109876543210
3420                                                      x0111010000xxxxxxxxx00xxxxxxxxxx
3421                                                      adcs.  */
3422                                                   return 1;
3423                                                 }
3424                                               else
3425                                                 {
3426                                                   /* 33222222222211111111110000000000
3427                                                      10987654321098765432109876543210
3428                                                      x1111010000xxxxxxxxx00xxxxxxxxxx
3429                                                      sbcs.  */
3430                                                   return 4;
3431                                                 }
3432                                             }
3433                                         }
3434                                       else
3435                                         {
3436                                           if (((word >> 30) & 0x1) == 0)
3437                                             {
3438                                               /* 33222222222211111111110000000000
3439                                                  10987654321098765432109876543210
3440                                                  x0x11010100xxxxxxxxx00xxxxxxxxxx
3441                                                  csel.  */
3442                                               return 662;
3443                                             }
3444                                           else
3445                                             {
3446                                               /* 33222222222211111111110000000000
3447                                                  10987654321098765432109876543210
3448                                                  x1x11010100xxxxxxxxx00xxxxxxxxxx
3449                                                  csinv.  */
3450                                               return 666;
3451                                             }
3452                                         }
3453                                     }
3454                                   else
3455                                     {
3456                                       if (((word >> 23) & 0x1) == 0)
3457                                         {
3458                                           if (((word >> 30) & 0x1) == 0)
3459                                             {
3460                                               /* 33222222222211111111110000000000
3461                                                  10987654321098765432109876543210
3462                                                  x0x11010010xxxxxxxxx00xxxxxxxxxx
3463                                                  ccmn.  */
3464                                               return 660;
3465                                             }
3466                                           else
3467                                             {
3468                                               /* 33222222222211111111110000000000
3469                                                  10987654321098765432109876543210
3470                                                  x1x11010010xxxxxxxxx00xxxxxxxxxx
3471                                                  ccmp.  */
3472                                               return 661;
3473                                             }
3474                                         }
3475                                       else
3476                                         {
3477                                           if (((word >> 12) & 0x1) == 0)
3478                                             {
3479                                               if (((word >> 13) & 0x1) == 0)
3480                                                 {
3481                                                   if (((word >> 14) & 0x1) == 0)
3482                                                     {
3483                                                       if (((word >> 29) & 0x1) == 0)
3484                                                         {
3485                                                           if (((word >> 30) & 0x1) == 0)
3486                                                             {
3487                                                               /* 33222222222211111111110000000000
3488                                                                  10987654321098765432109876543210
3489                                                                  x0011010110xxxxxx00000xxxxxxxxxx
3490                                                                  subp.  */
3491                                                               return 721;
3492                                                             }
3493                                                           else
3494                                                             {
3495                                                               if (((word >> 16) & 0x1) == 0)
3496                                                                 {
3497                                                                   /* 33222222222211111111110000000000
3498                                                                      10987654321098765432109876543210
3499                                                                      x1011010110xxxx0x00000xxxxxxxxxx
3500                                                                      rbit.  */
3501                                                                   return 685;
3502                                                                 }
3503                                                               else
3504                                                                 {
3505                                                                   /* 33222222222211111111110000000000
3506                                                                      10987654321098765432109876543210
3507                                                                      x1011010110xxxx1x00000xxxxxxxxxx
3508                                                                      pacia.  */
3509                                                                   return 693;
3510                                                                 }
3511                                                             }
3512                                                         }
3513                                                       else
3514                                                         {
3515                                                           /* 33222222222211111111110000000000
3516                                                              10987654321098765432109876543210
3517                                                              xx111010110xxxxxx00000xxxxxxxxxx
3518                                                              subps.  */
3519                                                           return 722;
3520                                                         }
3521                                                     }
3522                                                   else
3523                                                     {
3524                                                       if (((word >> 30) & 0x1) == 0)
3525                                                         {
3526                                                           /* 33222222222211111111110000000000
3527                                                              10987654321098765432109876543210
3528                                                              x0x11010110xxxxxx10000xxxxxxxxxx
3529                                                              crc32b.  */
3530                                                           return 727;
3531                                                         }
3532                                                       else
3533                                                         {
3534                                                           /* 33222222222211111111110000000000
3535                                                              10987654321098765432109876543210
3536                                                              x1x11010110xxxxxx10000xxxxxxxxxx
3537                                                              xpaci.  */
3538                                                           return 709;
3539                                                         }
3540                                                     }
3541                                                 }
3542                                               else
3543                                                 {
3544                                                   if (((word >> 30) & 0x1) == 0)
3545                                                     {
3546                                                       /* 33222222222211111111110000000000
3547                                                          10987654321098765432109876543210
3548                                                          x0x11010110xxxxxxx1000xxxxxxxxxx
3549                                                          lslv.  */
3550                                                       return 713;
3551                                                     }
3552                                                   else
3553                                                     {
3554                                                       /* 33222222222211111111110000000000
3555                                                          10987654321098765432109876543210
3556                                                          x1x11010110xxxxxxx1000xxxxxxxxxx
3557                                                          paciza.  */
3558                                                       return 701;
3559                                                     }
3560                                                 }
3561                                             }
3562                                           else
3563                                             {
3564                                               if (((word >> 13) & 0x1) == 0)
3565                                                 {
3566                                                   if (((word >> 14) & 0x1) == 0)
3567                                                     {
3568                                                       if (((word >> 30) & 0x1) == 0)
3569                                                         {
3570                                                           /* 33222222222211111111110000000000
3571                                                              10987654321098765432109876543210
3572                                                              x0x11010110xxxxxx00100xxxxxxxxxx
3573                                                              irg.  */
3574                                                           return 724;
3575                                                         }
3576                                                       else
3577                                                         {
3578                                                           if (((word >> 16) & 0x1) == 0)
3579                                                             {
3580                                                               /* 33222222222211111111110000000000
3581                                                                  10987654321098765432109876543210
3582                                                                  x1x11010110xxxx0x00100xxxxxxxxxx
3583                                                                  clz.  */
3584                                                               return 690;
3585                                                             }
3586                                                           else
3587                                                             {
3588                                                               /* 33222222222211111111110000000000
3589                                                                  10987654321098765432109876543210
3590                                                                  x1x11010110xxxx1x00100xxxxxxxxxx
3591                                                                  autia.  */
3592                                                               return 697;
3593                                                             }
3594                                                         }
3595                                                     }
3596                                                   else
3597                                                     {
3598                                                       /* 33222222222211111111110000000000
3599                                                          10987654321098765432109876543210
3600                                                          xxx11010110xxxxxx10100xxxxxxxxxx
3601                                                          crc32cb.  */
3602                                                       return 731;
3603                                                     }
3604                                                 }
3605                                               else
3606                                                 {
3607                                                   if (((word >> 30) & 0x1) == 0)
3608                                                     {
3609                                                       /* 33222222222211111111110000000000
3610                                                          10987654321098765432109876543210
3611                                                          x0x11010110xxxxxxx1100xxxxxxxxxx
3612                                                          pacga.  */
3613                                                       return 726;
3614                                                     }
3615                                                   else
3616                                                     {
3617                                                       /* 33222222222211111111110000000000
3618                                                          10987654321098765432109876543210
3619                                                          x1x11010110xxxxxxx1100xxxxxxxxxx
3620                                                          autiza.  */
3621                                                       return 705;
3622                                                     }
3623                                                 }
3624                                             }
3625                                         }
3626                                     }
3627                                 }
3628                               else
3629                                 {
3630                                   if (((word >> 22) & 0x1) == 0)
3631                                     {
3632                                       if (((word >> 14) & 0x1) == 0)
3633                                         {
3634                                           /* 33222222222211111111110000000000
3635                                              10987654321098765432109876543210
3636                                              xxx11010x00xxxxxx0xx10xxxxxxxxxx
3637                                              setf8.  */
3638                                           return 2449;
3639                                         }
3640                                       else
3641                                         {
3642                                           /* 33222222222211111111110000000000
3643                                              10987654321098765432109876543210
3644                                              xxx11010x00xxxxxx1xx10xxxxxxxxxx
3645                                              setf16.  */
3646                                           return 2450;
3647                                         }
3648                                     }
3649                                   else
3650                                     {
3651                                       if (((word >> 23) & 0x1) == 0)
3652                                         {
3653                                           if (((word >> 30) & 0x1) == 0)
3654                                             {
3655                                               /* 33222222222211111111110000000000
3656                                                  10987654321098765432109876543210
3657                                                  x0x11010010xxxxxxxxx10xxxxxxxxxx
3658                                                  ccmn.  */
3659                                               return 658;
3660                                             }
3661                                           else
3662                                             {
3663                                               /* 33222222222211111111110000000000
3664                                                  10987654321098765432109876543210
3665                                                  x1x11010010xxxxxxxxx10xxxxxxxxxx
3666                                                  ccmp.  */
3667                                               return 659;
3668                                             }
3669                                         }
3670                                       else
3671                                         {
3672                                           if (((word >> 12) & 0x1) == 0)
3673                                             {
3674                                               if (((word >> 13) & 0x1) == 0)
3675                                                 {
3676                                                   if (((word >> 14) & 0x1) == 0)
3677                                                     {
3678                                                       if (((word >> 30) & 0x1) == 0)
3679                                                         {
3680                                                           /* 33222222222211111111110000000000
3681                                                              10987654321098765432109876543210
3682                                                              x0x11010110xxxxxx00010xxxxxxxxxx
3683                                                              udiv.  */
3684                                                           return 711;
3685                                                         }
3686                                                       else
3687                                                         {
3688                                                           if (((word >> 16) & 0x1) == 0)
3689                                                             {
3690                                                               if (((word >> 31) & 0x1) == 0)
3691                                                                 {
3692                                                                   /* 33222222222211111111110000000000
3693                                                                      10987654321098765432109876543210
3694                                                                      01x11010110xxxx0x00010xxxxxxxxxx
3695                                                                      rev.  */
3696                                                                   return 687;
3697                                                                 }
3698                                                               else
3699                                                                 {
3700                                                                   /* 33222222222211111111110000000000
3701                                                                      10987654321098765432109876543210
3702                                                                      11x11010110xxxx0x00010xxxxxxxxxx
3703                                                                      rev32.  */
3704                                                                   return 692;
3705                                                                 }
3706                                                             }
3707                                                           else
3708                                                             {
3709                                                               /* 33222222222211111111110000000000
3710                                                                  10987654321098765432109876543210
3711                                                                  x1x11010110xxxx1x00010xxxxxxxxxx
3712                                                                  pacda.  */
3713                                                               return 695;
3714                                                             }
3715                                                         }
3716                                                     }
3717                                                   else
3718                                                     {
3719                                                       /* 33222222222211111111110000000000
3720                                                          10987654321098765432109876543210
3721                                                          xxx11010110xxxxxx10010xxxxxxxxxx
3722                                                          crc32w.  */
3723                                                       return 729;
3724                                                     }
3725                                                 }
3726                                               else
3727                                                 {
3728                                                   if (((word >> 30) & 0x1) == 0)
3729                                                     {
3730                                                       /* 33222222222211111111110000000000
3731                                                          10987654321098765432109876543210
3732                                                          x0x11010110xxxxxxx1010xxxxxxxxxx
3733                                                          asrv.  */
3734                                                       return 717;
3735                                                     }
3736                                                   else
3737                                                     {
3738                                                       /* 33222222222211111111110000000000
3739                                                          10987654321098765432109876543210
3740                                                          x1x11010110xxxxxxx1010xxxxxxxxxx
3741                                                          pacdza.  */
3742                                                       return 703;
3743                                                     }
3744                                                 }
3745                                             }
3746                                           else
3747                                             {
3748                                               if (((word >> 13) & 0x1) == 0)
3749                                                 {
3750                                                   if (((word >> 14) & 0x1) == 0)
3751                                                     {
3752                                                       /* 33222222222211111111110000000000
3753                                                          10987654321098765432109876543210
3754                                                          xxx11010110xxxxxx00110xxxxxxxxxx
3755                                                          autda.  */
3756                                                       return 699;
3757                                                     }
3758                                                   else
3759                                                     {
3760                                                       /* 33222222222211111111110000000000
3761                                                          10987654321098765432109876543210
3762                                                          xxx11010110xxxxxx10110xxxxxxxxxx
3763                                                          crc32cw.  */
3764                                                       return 733;
3765                                                     }
3766                                                 }
3767                                               else
3768                                                 {
3769                                                   /* 33222222222211111111110000000000
3770                                                      10987654321098765432109876543210
3771                                                      xxx11010110xxxxxxx1110xxxxxxxxxx
3772                                                      autdza.  */
3773                                                   return 707;
3774                                                 }
3775                                             }
3776                                         }
3777                                     }
3778                                 }
3779                             }
3780                           else
3781                             {
3782                               if (((word >> 11) & 0x1) == 0)
3783                                 {
3784                                   if (((word >> 22) & 0x1) == 0)
3785                                     {
3786                                       if (((word >> 23) & 0x1) == 0)
3787                                         {
3788                                           /* 33222222222211111111110000000000
3789                                              10987654321098765432109876543210
3790                                              xxx11010000xxxxxxxxx01xxxxxxxxxx
3791                                              rmif.  */
3792                                           return 2448;
3793                                         }
3794                                       else
3795                                         {
3796                                           if (((word >> 30) & 0x1) == 0)
3797                                             {
3798                                               /* 33222222222211111111110000000000
3799                                                  10987654321098765432109876543210
3800                                                  x0x11010100xxxxxxxxx01xxxxxxxxxx
3801                                                  csinc.  */
3802                                               return 663;
3803                                             }
3804                                           else
3805                                             {
3806                                               /* 33222222222211111111110000000000
3807                                                  10987654321098765432109876543210
3808                                                  x1x11010100xxxxxxxxx01xxxxxxxxxx
3809                                                  csneg.  */
3810                                               return 669;
3811                                             }
3812                                         }
3813                                     }
3814                                   else
3815                                     {
3816                                       if (((word >> 12) & 0x1) == 0)
3817                                         {
3818                                           if (((word >> 13) & 0x1) == 0)
3819                                             {
3820                                               if (((word >> 14) & 0x1) == 0)
3821                                                 {
3822                                                   if (((word >> 16) & 0x1) == 0)
3823                                                     {
3824                                                       /* 33222222222211111111110000000000
3825                                                          10987654321098765432109876543210
3826                                                          xxx11010x10xxxx0x00001xxxxxxxxxx
3827                                                          rev16.  */
3828                                                       return 686;
3829                                                     }
3830                                                   else
3831                                                     {
3832                                                       /* 33222222222211111111110000000000
3833                                                          10987654321098765432109876543210
3834                                                          xxx11010x10xxxx1x00001xxxxxxxxxx
3835                                                          pacib.  */
3836                                                       return 694;
3837                                                     }
3838                                                 }
3839                                               else
3840                                                 {
3841                                                   if (((word >> 30) & 0x1) == 0)
3842                                                     {
3843                                                       /* 33222222222211111111110000000000
3844                                                          10987654321098765432109876543210
3845                                                          x0x11010x10xxxxxx10001xxxxxxxxxx
3846                                                          crc32h.  */
3847                                                       return 728;
3848                                                     }
3849                                                   else
3850                                                     {
3851                                                       /* 33222222222211111111110000000000
3852                                                          10987654321098765432109876543210
3853                                                          x1x11010x10xxxxxx10001xxxxxxxxxx
3854                                                          xpacd.  */
3855                                                       return 710;
3856                                                     }
3857                                                 }
3858                                             }
3859                                           else
3860                                             {
3861                                               if (((word >> 30) & 0x1) == 0)
3862                                                 {
3863                                                   /* 33222222222211111111110000000000
3864                                                      10987654321098765432109876543210
3865                                                      x0x11010x10xxxxxxx1001xxxxxxxxxx
3866                                                      lsrv.  */
3867                                                   return 715;
3868                                                 }
3869                                               else
3870                                                 {
3871                                                   /* 33222222222211111111110000000000
3872                                                      10987654321098765432109876543210
3873                                                      x1x11010x10xxxxxxx1001xxxxxxxxxx
3874                                                      pacizb.  */
3875                                                   return 702;
3876                                                 }
3877                                             }
3878                                         }
3879                                       else
3880                                         {
3881                                           if (((word >> 13) & 0x1) == 0)
3882                                             {
3883                                               if (((word >> 14) & 0x1) == 0)
3884                                                 {
3885                                                   if (((word >> 30) & 0x1) == 0)
3886                                                     {
3887                                                       /* 33222222222211111111110000000000
3888                                                          10987654321098765432109876543210
3889                                                          x0x11010x10xxxxxx00101xxxxxxxxxx
3890                                                          gmi.  */
3891                                                       return 725;
3892                                                     }
3893                                                   else
3894                                                     {
3895                                                       if (((word >> 16) & 0x1) == 0)
3896                                                         {
3897                                                           /* 33222222222211111111110000000000
3898                                                              10987654321098765432109876543210
3899                                                              x1x11010x10xxxx0x00101xxxxxxxxxx
3900                                                              cls.  */
3901                                                           return 691;
3902                                                         }
3903                                                       else
3904                                                         {
3905                                                           /* 33222222222211111111110000000000
3906                                                              10987654321098765432109876543210
3907                                                              x1x11010x10xxxx1x00101xxxxxxxxxx
3908                                                              autib.  */
3909                                                           return 698;
3910                                                         }
3911                                                     }
3912                                                 }
3913                                               else
3914                                                 {
3915                                                   /* 33222222222211111111110000000000
3916                                                      10987654321098765432109876543210
3917                                                      xxx11010x10xxxxxx10101xxxxxxxxxx
3918                                                      crc32ch.  */
3919                                                   return 732;
3920                                                 }
3921                                             }
3922                                           else
3923                                             {
3924                                               /* 33222222222211111111110000000000
3925                                                  10987654321098765432109876543210
3926                                                  xxx11010x10xxxxxxx1101xxxxxxxxxx
3927                                                  autizb.  */
3928                                               return 706;
3929                                             }
3930                                         }
3931                                     }
3932                                 }
3933                               else
3934                                 {
3935                                   if (((word >> 12) & 0x1) == 0)
3936                                     {
3937                                       if (((word >> 13) & 0x1) == 0)
3938                                         {
3939                                           if (((word >> 14) & 0x1) == 0)
3940                                             {
3941                                               if (((word >> 30) & 0x1) == 0)
3942                                                 {
3943                                                   /* 33222222222211111111110000000000
3944                                                      10987654321098765432109876543210
3945                                                      x0x11010xx0xxxxxx00011xxxxxxxxxx
3946                                                      sdiv.  */
3947                                                   return 712;
3948                                                 }
3949                                               else
3950                                                 {
3951                                                   if (((word >> 16) & 0x1) == 0)
3952                                                     {
3953                                                       /* 33222222222211111111110000000000
3954                                                          10987654321098765432109876543210
3955                                                          x1x11010xx0xxxx0x00011xxxxxxxxxx
3956                                                          rev.  */
3957                                                       return 688;
3958                                                     }
3959                                                   else
3960                                                     {
3961                                                       /* 33222222222211111111110000000000
3962                                                          10987654321098765432109876543210
3963                                                          x1x11010xx0xxxx1x00011xxxxxxxxxx
3964                                                          pacdb.  */
3965                                                       return 696;
3966                                                     }
3967                                                 }
3968                                             }
3969                                           else
3970                                             {
3971                                               /* 33222222222211111111110000000000
3972                                                  10987654321098765432109876543210
3973                                                  xxx11010xx0xxxxxx10011xxxxxxxxxx
3974                                                  crc32x.  */
3975                                               return 730;
3976                                             }
3977                                         }
3978                                       else
3979                                         {
3980                                           if (((word >> 30) & 0x1) == 0)
3981                                             {
3982                                               /* 33222222222211111111110000000000
3983                                                  10987654321098765432109876543210
3984                                                  x0x11010xx0xxxxxxx1011xxxxxxxxxx
3985                                                  rorv.  */
3986                                               return 719;
3987                                             }
3988                                           else
3989                                             {
3990                                               /* 33222222222211111111110000000000
3991                                                  10987654321098765432109876543210
3992                                                  x1x11010xx0xxxxxxx1011xxxxxxxxxx
3993                                                  pacdzb.  */
3994                                               return 704;
3995                                             }
3996                                         }
3997                                     }
3998                                   else
3999                                     {
4000                                       if (((word >> 13) & 0x1) == 0)
4001                                         {
4002                                           if (((word >> 14) & 0x1) == 0)
4003                                             {
4004                                               /* 33222222222211111111110000000000
4005                                                  10987654321098765432109876543210
4006                                                  xxx11010xx0xxxxxx00111xxxxxxxxxx
4007                                                  autdb.  */
4008                                               return 700;
4009                                             }
4010                                           else
4011                                             {
4012                                               /* 33222222222211111111110000000000
4013                                                  10987654321098765432109876543210
4014                                                  xxx11010xx0xxxxxx10111xxxxxxxxxx
4015                                                  crc32cx.  */
4016                                               return 734;
4017                                             }
4018                                         }
4019                                       else
4020                                         {
4021                                           /* 33222222222211111111110000000000
4022                                              10987654321098765432109876543210
4023                                              xxx11010xx0xxxxxxx1111xxxxxxxxxx
4024                                              autdzb.  */
4025                                           return 708;
4026                                         }
4027                                     }
4028                                 }
4029                             }
4030                         }
4031                     }
4032                   else
4033                     {
4034                       if (((word >> 29) & 0x1) == 0)
4035                         {
4036                           if (((word >> 30) & 0x1) == 0)
4037                             {
4038                               /* 33222222222211111111110000000000
4039                                  10987654321098765432109876543210
4040                                  x00x1010xx1xxxxxxxxxxxxxxxxxxxxx
4041                                  bic.  */
4042                               return 1003;
4043                             }
4044                           else
4045                             {
4046                               /* 33222222222211111111110000000000
4047                                  10987654321098765432109876543210
4048                                  x10x1010xx1xxxxxxxxxxxxxxxxxxxxx
4049                                  eon.  */
4050                               return 1010;
4051                             }
4052                         }
4053                       else
4054                         {
4055                           if (((word >> 30) & 0x1) == 0)
4056                             {
4057                               /* 33222222222211111111110000000000
4058                                  10987654321098765432109876543210
4059                                  x01x1010xx1xxxxxxxxxxxxxxxxxxxxx
4060                                  orn.  */
4061                               return 1007;
4062                             }
4063                           else
4064                             {
4065                               /* 33222222222211111111110000000000
4066                                  10987654321098765432109876543210
4067                                  x11x1010xx1xxxxxxxxxxxxxxxxxxxxx
4068                                  bics.  */
4069                               return 1013;
4070                             }
4071                         }
4072                     }
4073                 }
4074             }
4075           else
4076             {
4077               if (((word >> 27) & 0x1) == 0)
4078                 {
4079                   if (((word >> 23) & 0x1) == 0)
4080                     {
4081                       if (((word >> 29) & 0x1) == 0)
4082                         {
4083                           if (((word >> 30) & 0x1) == 0)
4084                             {
4085                               /* 33222222222211111111110000000000
4086                                  10987654321098765432109876543210
4087                                  x00x00110xxxxxxxxxxxxxxxxxxxxxxx
4088                                  sbfm.  */
4089                               return 618;
4090                             }
4091                           else
4092                             {
4093                               /* 33222222222211111111110000000000
4094                                  10987654321098765432109876543210
4095                                  x10x00110xxxxxxxxxxxxxxxxxxxxxxx
4096                                  ubfm.  */
4097                               return 629;
4098                             }
4099                         }
4100                       else
4101                         {
4102                           /* 33222222222211111111110000000000
4103                              10987654321098765432109876543210
4104                              xx1x00110xxxxxxxxxxxxxxxxxxxxxxx
4105                              bfm.  */
4106                           return 625;
4107                         }
4108                     }
4109                   else
4110                     {
4111                       /* 33222222222211111111110000000000
4112                          10987654321098765432109876543210
4113                          xxxx00111xxxxxxxxxxxxxxxxxxxxxxx
4114                          extr.  */
4115                       return 758;
4116                     }
4117                 }
4118               else
4119                 {
4120                   if (((word >> 21) & 0x1) == 0)
4121                     {
4122                       if (((word >> 28) & 0x1) == 0)
4123                         {
4124                           if (((word >> 29) & 0x1) == 0)
4125                             {
4126                               if (((word >> 30) & 0x1) == 0)
4127                                 {
4128                                   /* 33222222222211111111110000000000
4129                                      10987654321098765432109876543210
4130                                      x0001011xx0xxxxxxxxxxxxxxxxxxxxx
4131                                      add.  */
4132                                   return 21;
4133                                 }
4134                               else
4135                                 {
4136                                   /* 33222222222211111111110000000000
4137                                      10987654321098765432109876543210
4138                                      x1001011xx0xxxxxxxxxxxxxxxxxxxxx
4139                                      sub.  */
4140                                   return 24;
4141                                 }
4142                             }
4143                           else
4144                             {
4145                               if (((word >> 30) & 0x1) == 0)
4146                                 {
4147                                   /* 33222222222211111111110000000000
4148                                      10987654321098765432109876543210
4149                                      x0101011xx0xxxxxxxxxxxxxxxxxxxxx
4150                                      adds.  */
4151                                   return 22;
4152                                 }
4153                               else
4154                                 {
4155                                   /* 33222222222211111111110000000000
4156                                      10987654321098765432109876543210
4157                                      x1101011xx0xxxxxxxxxxxxxxxxxxxxx
4158                                      subs.  */
4159                                   return 26;
4160                                 }
4161                             }
4162                         }
4163                       else
4164                         {
4165                           if (((word >> 15) & 0x1) == 0)
4166                             {
4167                               if (((word >> 22) & 0x1) == 0)
4168                                 {
4169                                   /* 33222222222211111111110000000000
4170                                      10987654321098765432109876543210
4171                                      xxx11011x00xxxxx0xxxxxxxxxxxxxxx
4172                                      madd.  */
4173                                   return 735;
4174                                 }
4175                               else
4176                                 {
4177                                   if (((word >> 23) & 0x1) == 0)
4178                                     {
4179                                       /* 33222222222211111111110000000000
4180                                          10987654321098765432109876543210
4181                                          xxx11011010xxxxx0xxxxxxxxxxxxxxx
4182                                          smulh.  */
4183                                       return 743;
4184                                     }
4185                                   else
4186                                     {
4187                                       /* 33222222222211111111110000000000
4188                                          10987654321098765432109876543210
4189                                          xxx11011110xxxxx0xxxxxxxxxxxxxxx
4190                                          umulh.  */
4191                                       return 748;
4192                                     }
4193                                 }
4194                             }
4195                           else
4196                             {
4197                               /* 33222222222211111111110000000000
4198                                  10987654321098765432109876543210
4199                                  xxx11011xx0xxxxx1xxxxxxxxxxxxxxx
4200                                  msub.  */
4201                               return 737;
4202                             }
4203                         }
4204                     }
4205                   else
4206                     {
4207                       if (((word >> 23) & 0x1) == 0)
4208                         {
4209                           if (((word >> 28) & 0x1) == 0)
4210                             {
4211                               if (((word >> 29) & 0x1) == 0)
4212                                 {
4213                                   if (((word >> 30) & 0x1) == 0)
4214                                     {
4215                                       /* 33222222222211111111110000000000
4216                                          10987654321098765432109876543210
4217                                          x00010110x1xxxxxxxxxxxxxxxxxxxxx
4218                                          add.  */
4219                                       return 6;
4220                                     }
4221                                   else
4222                                     {
4223                                       /* 33222222222211111111110000000000
4224                                          10987654321098765432109876543210
4225                                          x10010110x1xxxxxxxxxxxxxxxxxxxxx
4226                                          sub.  */
4227                                       return 9;
4228                                     }
4229                                 }
4230                               else
4231                                 {
4232                                   if (((word >> 30) & 0x1) == 0)
4233                                     {
4234                                       /* 33222222222211111111110000000000
4235                                          10987654321098765432109876543210
4236                                          x01010110x1xxxxxxxxxxxxxxxxxxxxx
4237                                          adds.  */
4238                                       return 7;
4239                                     }
4240                                   else
4241                                     {
4242                                       /* 33222222222211111111110000000000
4243                                          10987654321098765432109876543210
4244                                          x11010110x1xxxxxxxxxxxxxxxxxxxxx
4245                                          subs.  */
4246                                       return 10;
4247                                     }
4248                                 }
4249                             }
4250                           else
4251                             {
4252                               if (((word >> 15) & 0x1) == 0)
4253                                 {
4254                                   /* 33222222222211111111110000000000
4255                                      10987654321098765432109876543210
4256                                      xxx110110x1xxxxx0xxxxxxxxxxxxxxx
4257                                      smaddl.  */
4258                                   return 739;
4259                                 }
4260                               else
4261                                 {
4262                                   /* 33222222222211111111110000000000
4263                                      10987654321098765432109876543210
4264                                      xxx110110x1xxxxx1xxxxxxxxxxxxxxx
4265                                      smsubl.  */
4266                                   return 741;
4267                                 }
4268                             }
4269                         }
4270                       else
4271                         {
4272                           if (((word >> 15) & 0x1) == 0)
4273                             {
4274                               /* 33222222222211111111110000000000
4275                                  10987654321098765432109876543210
4276                                  xxxx10111x1xxxxx0xxxxxxxxxxxxxxx
4277                                  umaddl.  */
4278                               return 744;
4279                             }
4280                           else
4281                             {
4282                               /* 33222222222211111111110000000000
4283                                  10987654321098765432109876543210
4284                                  xxxx10111x1xxxxx1xxxxxxxxxxxxxxx
4285                                  umsubl.  */
4286                               return 746;
4287                             }
4288                         }
4289                     }
4290                 }
4291             }
4292         }
4293     }
4294   else
4295     {
4296       if (((word >> 27) & 0x1) == 0)
4297         {
4298           if (((word >> 28) & 0x1) == 0)
4299             {
4300               if (((word >> 24) & 0x1) == 0)
4301                 {
4302                   if (((word >> 29) & 0x1) == 0)
4303                     {
4304                       if (((word >> 13) & 0x1) == 0)
4305                         {
4306                           if (((word >> 14) & 0x1) == 0)
4307                             {
4308                               if (((word >> 15) & 0x1) == 0)
4309                                 {
4310                                   if (((word >> 21) & 0x1) == 0)
4311                                     {
4312                                       if (((word >> 30) & 0x1) == 0)
4313                                         {
4314                                           if (((word >> 31) & 0x1) == 0)
4315                                             {
4316                                               if (((word >> 16) & 0x1) == 0)
4317                                                 {
4318                                                   if (((word >> 17) & 0x1) == 0)
4319                                                     {
4320                                                       if (((word >> 18) & 0x1) == 0)
4321                                                         {
4322                                                           if (((word >> 19) & 0x1) == 0)
4323                                                             {
4324                                                               if (((word >> 20) & 0x1) == 0)
4325                                                                 {
4326                                                                   /* 33222222222211111111110000000000
4327                                                                      10987654321098765432109876543210
4328                                                                      000001x0xx000000000xxxxxxxxxxxxx
4329                                                                      add.  */
4330                                                                   return 1291;
4331                                                                 }
4332                                                               else
4333                                                                 {
4334                                                                   /* 33222222222211111111110000000000
4335                                                                      10987654321098765432109876543210
4336                                                                      000001x0xx010000000xxxxxxxxxxxxx
4337                                                                      mul.  */
4338                                                                   return 1760;
4339                                                                 }
4340                                                             }
4341                                                           else
4342                                                             {
4343                                                               if (((word >> 20) & 0x1) == 0)
4344                                                                 {
4345                                                                   /* 33222222222211111111110000000000
4346                                                                      10987654321098765432109876543210
4347                                                                      000001x0xx001000000xxxxxxxxxxxxx
4348                                                                      smax.  */
4349                                                                   return 1839;
4350                                                                 }
4351                                                               else
4352                                                                 {
4353                                                                   /* 33222222222211111111110000000000
4354                                                                      10987654321098765432109876543210
4355                                                                      000001x0xx011000000xxxxxxxxxxxxx
4356                                                                      orr.  */
4357                                                                   return 1771;
4358                                                                 }
4359                                                             }
4360                                                         }
4361                                                       else
4362                                                         {
4363                                                           if (((word >> 19) & 0x1) == 0)
4364                                                             {
4365                                                               /* 33222222222211111111110000000000
4366                                                                  10987654321098765432109876543210
4367                                                                  000001x0xx0x0100000xxxxxxxxxxxxx
4368                                                                  sdiv.  */
4369                                                               return 1830;
4370                                                             }
4371                                                           else
4372                                                             {
4373                                                               /* 33222222222211111111110000000000
4374                                                                  10987654321098765432109876543210
4375                                                                  000001x0xx0x1100000xxxxxxxxxxxxx
4376                                                                  sabd.  */
4377                                                               return 1821;
4378                                                             }
4379                                                         }
4380                                                     }
4381                                                   else
4382                                                     {
4383                                                       if (((word >> 18) & 0x1) == 0)
4384                                                         {
4385                                                           if (((word >> 19) & 0x1) == 0)
4386                                                             {
4387                                                               /* 33222222222211111111110000000000
4388                                                                  10987654321098765432109876543210
4389                                                                  000001x0xx0x0010000xxxxxxxxxxxxx
4390                                                                  smulh.  */
4391                                                               return 1844;
4392                                                             }
4393                                                           else
4394                                                             {
4395                                                               if (((word >> 20) & 0x1) == 0)
4396                                                                 {
4397                                                                   /* 33222222222211111111110000000000
4398                                                                      10987654321098765432109876543210
4399                                                                      000001x0xx001010000xxxxxxxxxxxxx
4400                                                                      smin.  */
4401                                                                   return 1842;
4402                                                                 }
4403                                                               else
4404                                                                 {
4405                                                                   /* 33222222222211111111110000000000
4406                                                                      10987654321098765432109876543210
4407                                                                      000001x0xx011010000xxxxxxxxxxxxx
4408                                                                      and.  */
4409                                                                   return 1299;
4410                                                                 }
4411                                                             }
4412                                                         }
4413                                                       else
4414                                                         {
4415                                                           /* 33222222222211111111110000000000
4416                                                              10987654321098765432109876543210
4417                                                              000001x0xx0xx110000xxxxxxxxxxxxx
4418                                                              sdivr.  */
4419                                                           return 1831;
4420                                                         }
4421                                                     }
4422                                                 }
4423                                               else
4424                                                 {
4425                                                   if (((word >> 17) & 0x1) == 0)
4426                                                     {
4427                                                       if (((word >> 18) & 0x1) == 0)
4428                                                         {
4429                                                           if (((word >> 19) & 0x1) == 0)
4430                                                             {
4431                                                               /* 33222222222211111111110000000000
4432                                                                  10987654321098765432109876543210
4433                                                                  000001x0xx0x0001000xxxxxxxxxxxxx
4434                                                                  sub.  */
4435                                                               return 1960;
4436                                                             }
4437                                                           else
4438                                                             {
4439                                                               if (((word >> 20) & 0x1) == 0)
4440                                                                 {
4441                                                                   /* 33222222222211111111110000000000
4442                                                                      10987654321098765432109876543210
4443                                                                      000001x0xx001001000xxxxxxxxxxxxx
4444                                                                      umax.  */
4445                                                                   return 1988;
4446                                                                 }
4447                                                               else
4448                                                                 {
4449                                                                   /* 33222222222211111111110000000000
4450                                                                      10987654321098765432109876543210
4451                                                                      000001x0xx011001000xxxxxxxxxxxxx
4452                                                                      eor.  */
4453                                                                   return 1386;
4454                                                                 }
4455                                                             }
4456                                                         }
4457                                                       else
4458                                                         {
4459                                                           if (((word >> 19) & 0x1) == 0)
4460                                                             {
4461                                                               /* 33222222222211111111110000000000
4462                                                                  10987654321098765432109876543210
4463                                                                  000001x0xx0x0101000xxxxxxxxxxxxx
4464                                                                  udiv.  */
4465                                                               return 1982;
4466                                                             }
4467                                                           else
4468                                                             {
4469                                                               /* 33222222222211111111110000000000
4470                                                                  10987654321098765432109876543210
4471                                                                  000001x0xx0x1101000xxxxxxxxxxxxx
4472                                                                  uabd.  */
4473                                                               return 1973;
4474                                                             }
4475                                                         }
4476                                                     }
4477                                                   else
4478                                                     {
4479                                                       if (((word >> 18) & 0x1) == 0)
4480                                                         {
4481                                                           if (((word >> 19) & 0x1) == 0)
4482                                                             {
4483                                                               if (((word >> 20) & 0x1) == 0)
4484                                                                 {
4485                                                                   /* 33222222222211111111110000000000
4486                                                                      10987654321098765432109876543210
4487                                                                      000001x0xx000011000xxxxxxxxxxxxx
4488                                                                      subr.  */
4489                                                                   return 1962;
4490                                                                 }
4491                                                               else
4492                                                                 {
4493                                                                   /* 33222222222211111111110000000000
4494                                                                      10987654321098765432109876543210
4495                                                                      000001x0xx010011000xxxxxxxxxxxxx
4496                                                                      umulh.  */
4497                                                                   return 1993;
4498                                                                 }
4499                                                             }
4500                                                           else
4501                                                             {
4502                                                               if (((word >> 20) & 0x1) == 0)
4503                                                                 {
4504                                                                   /* 33222222222211111111110000000000
4505                                                                      10987654321098765432109876543210
4506                                                                      000001x0xx001011000xxxxxxxxxxxxx
4507                                                                      umin.  */
4508                                                                   return 1991;
4509                                                                 }
4510                                                               else
4511                                                                 {
4512                                                                   /* 33222222222211111111110000000000
4513                                                                      10987654321098765432109876543210
4514                                                                      000001x0xx011011000xxxxxxxxxxxxx
4515                                                                      bic.  */
4516                                                                   return 1311;
4517                                                                 }
4518                                                             }
4519                                                         }
4520                                                       else
4521                                                         {
4522                                                           /* 33222222222211111111110000000000
4523                                                              10987654321098765432109876543210
4524                                                              000001x0xx0xx111000xxxxxxxxxxxxx
4525                                                              udivr.  */
4526                                                           return 1983;
4527                                                         }
4528                                                     }
4529                                                 }
4530                                             }
4531                                           else
4532                                             {
4533                                               if (((word >> 23) & 0x1) == 0)
4534                                                 {
4535                                                   /* 33222222222211111111110000000000
4536                                                      10987654321098765432109876543210
4537                                                      100001x00x0xxxxx000xxxxxxxxxxxxx
4538                                                      ld1sb.  */
4539                                                   return 1573;
4540                                                 }
4541                                               else
4542                                                 {
4543                                                   /* 33222222222211111111110000000000
4544                                                      10987654321098765432109876543210
4545                                                      100001x01x0xxxxx000xxxxxxxxxxxxx
4546                                                      ld1sh.  */
4547                                                   return 1584;
4548                                                 }
4549                                             }
4550                                         }
4551                                       else
4552                                         {
4553                                           if (((word >> 31) & 0x1) == 0)
4554                                             {
4555                                               if (((word >> 12) & 0x1) == 0)
4556                                                 {
4557                                                   if (((word >> 10) & 0x1) == 0)
4558                                                     {
4559                                                       if (((word >> 11) & 0x1) == 0)
4560                                                         {
4561                                                           /* 33222222222211111111110000000000
4562                                                              10987654321098765432109876543210
4563                                                              010001x0xx0xxxxx000000xxxxxxxxxx
4564                                                              sdot.  */
4565                                                           return 1832;
4566                                                         }
4567                                                       else
4568                                                         {
4569                                                           /* 33222222222211111111110000000000
4570                                                              10987654321098765432109876543210
4571                                                              010001x0xx0xxxxx000010xxxxxxxxxx
4572                                                              sqdmlalbt.  */
4573                                                           return 2182;
4574                                                         }
4575                                                     }
4576                                                   else
4577                                                     {
4578                                                       if (((word >> 11) & 0x1) == 0)
4579                                                         {
4580                                                           /* 33222222222211111111110000000000
4581                                                              10987654321098765432109876543210
4582                                                              010001x0xx0xxxxx000001xxxxxxxxxx
4583                                                              udot.  */
4584                                                           return 1984;
4585                                                         }
4586                                                       else
4587                                                         {
4588                                                           /* 33222222222211111111110000000000
4589                                                              10987654321098765432109876543210
4590                                                              010001x0xx0xxxxx000011xxxxxxxxxx
4591                                                              sqdmlslbt.  */
4592                                                           return 2189;
4593                                                         }
4594                                                     }
4595                                                 }
4596                                               else
4597                                                 {
4598                                                   /* 33222222222211111111110000000000
4599                                                      10987654321098765432109876543210
4600                                                      010001x0xx0xxxxx0001xxxxxxxxxxxx
4601                                                      cdot.  */
4602                                                   return 2071;
4603                                                 }
4604                                             }
4605                                           else
4606                                             {
4607                                               if (((word >> 23) & 0x1) == 0)
4608                                                 {
4609                                                   /* 33222222222211111111110000000000
4610                                                      10987654321098765432109876543210
4611                                                      110001x00x0xxxxx000xxxxxxxxxxxxx
4612                                                      ld1sb.  */
4613                                                   return 1577;
4614                                                 }
4615                                               else
4616                                                 {
4617                                                   /* 33222222222211111111110000000000
4618                                                      10987654321098765432109876543210
4619                                                      110001x01x0xxxxx000xxxxxxxxxxxxx
4620                                                      ld1sh.  */
4621                                                   return 1588;
4622                                                 }
4623                                             }
4624                                         }
4625                                     }
4626                                   else
4627                                     {
4628                                       if (((word >> 30) & 0x1) == 0)
4629                                         {
4630                                           if (((word >> 31) & 0x1) == 0)
4631                                             {
4632                                               if (((word >> 10) & 0x1) == 0)
4633                                                 {
4634                                                   if (((word >> 11) & 0x1) == 0)
4635                                                     {
4636                                                       if (((word >> 12) & 0x1) == 0)
4637                                                         {
4638                                                           /* 33222222222211111111110000000000
4639                                                              10987654321098765432109876543210
4640                                                              000001x0xx1xxxxx000000xxxxxxxxxx
4641                                                              add.  */
4642                                                           return 1289;
4643                                                         }
4644                                                       else
4645                                                         {
4646                                                           /* 33222222222211111111110000000000
4647                                                              10987654321098765432109876543210
4648                                                              000001x0xx1xxxxx000100xxxxxxxxxx
4649                                                              sqadd.  */
4650                                                           return 1846;
4651                                                         }
4652                                                     }
4653                                                   else
4654                                                     {
4655                                                       /* 33222222222211111111110000000000
4656                                                          10987654321098765432109876543210
4657                                                          000001x0xx1xxxxx000x10xxxxxxxxxx
4658                                                          sqsub.  */
4659                                                       return 1876;
4660                                                     }
4661                                                 }
4662                                               else
4663                                                 {
4664                                                   if (((word >> 11) & 0x1) == 0)
4665                                                     {
4666                                                       if (((word >> 12) & 0x1) == 0)
4667                                                         {
4668                                                           /* 33222222222211111111110000000000
4669                                                              10987654321098765432109876543210
4670                                                              000001x0xx1xxxxx000001xxxxxxxxxx
4671                                                              sub.  */
4672                                                           return 1958;
4673                                                         }
4674                                                       else
4675                                                         {
4676                                                           /* 33222222222211111111110000000000
4677                                                              10987654321098765432109876543210
4678                                                              000001x0xx1xxxxx000101xxxxxxxxxx
4679                                                              uqadd.  */
4680                                                           return 1994;
4681                                                         }
4682                                                     }
4683                                                   else
4684                                                     {
4685                                                       /* 33222222222211111111110000000000
4686                                                          10987654321098765432109876543210
4687                                                          000001x0xx1xxxxx000x11xxxxxxxxxx
4688                                                          uqsub.  */
4689                                                       return 2024;
4690                                                     }
4691                                                 }
4692                                             }
4693                                           else
4694                                             {
4695                                               if (((word >> 23) & 0x1) == 0)
4696                                                 {
4697                                                   /* 33222222222211111111110000000000
4698                                                      10987654321098765432109876543210
4699                                                      100001x00x1xxxxx000xxxxxxxxxxxxx
4700                                                      prfb.  */
4701                                                   return 1779;
4702                                                 }
4703                                               else
4704                                                 {
4705                                                   /* 33222222222211111111110000000000
4706                                                      10987654321098765432109876543210
4707                                                      100001x01x1xxxxx000xxxxxxxxxxxxx
4708                                                      ld1sh.  */
4709                                                   return 1585;
4710                                                 }
4711                                             }
4712                                         }
4713                                       else
4714                                         {
4715                                           if (((word >> 23) & 0x1) == 0)
4716                                             {
4717                                               if (((word >> 31) & 0x1) == 0)
4718                                                 {
4719                                                   if (((word >> 10) & 0x1) == 0)
4720                                                     {
4721                                                       if (((word >> 11) & 0x1) == 0)
4722                                                         {
4723                                                           /* 33222222222211111111110000000000
4724                                                              10987654321098765432109876543210
4725                                                              010001x00x1xxxxx000x00xxxxxxxxxx
4726                                                              sqrdmlah.  */
4727                                                           return 2207;
4728                                                         }
4729                                                       else
4730                                                         {
4731                                                           /* 33222222222211111111110000000000
4732                                                              10987654321098765432109876543210
4733                                                              010001x00x1xxxxx000x10xxxxxxxxxx
4734                                                              mla.  */
4735                                                           return 2114;
4736                                                         }
4737                                                     }
4738                                                   else
4739                                                     {
4740                                                       if (((word >> 11) & 0x1) == 0)
4741                                                         {
4742                                                           /* 33222222222211111111110000000000
4743                                                              10987654321098765432109876543210
4744                                                              010001x00x1xxxxx000x01xxxxxxxxxx
4745                                                              sqrdmlsh.  */
4746                                                           return 2211;
4747                                                         }
4748                                                       else
4749                                                         {
4750                                                           /* 33222222222211111111110000000000
4751                                                              10987654321098765432109876543210
4752                                                              010001x00x1xxxxx000x11xxxxxxxxxx
4753                                                              mls.  */
4754                                                           return 2117;
4755                                                         }
4756                                                     }
4757                                                 }
4758                                               else
4759                                                 {
4760                                                   /* 33222222222211111111110000000000
4761                                                      10987654321098765432109876543210
4762                                                      110001x00x1xxxxx000xxxxxxxxxxxxx
4763                                                      prfb.  */
4764                                                   return 1780;
4765                                                 }
4766                                             }
4767                                           else
4768                                             {
4769                                               if (((word >> 31) & 0x1) == 0)
4770                                                 {
4771                                                   if (((word >> 10) & 0x1) == 0)
4772                                                     {
4773                                                       if (((word >> 11) & 0x1) == 0)
4774                                                         {
4775                                                           if (((word >> 12) & 0x1) == 0)
4776                                                             {
4777                                                               if (((word >> 22) & 0x1) == 0)
4778                                                                 {
4779                                                                   /* 33222222222211111111110000000000
4780                                                                      10987654321098765432109876543210
4781                                                                      010001x0101xxxxx000000xxxxxxxxxx
4782                                                                      sdot.  */
4783                                                                   return 1833;
4784                                                                 }
4785                                                               else
4786                                                                 {
4787                                                                   /* 33222222222211111111110000000000
4788                                                                      10987654321098765432109876543210
4789                                                                      010001x0111xxxxx000000xxxxxxxxxx
4790                                                                      sdot.  */
4791                                                                   return 1834;
4792                                                                 }
4793                                                             }
4794                                                           else
4795                                                             {
4796                                                               if (((word >> 22) & 0x1) == 0)
4797                                                                 {
4798                                                                   /* 33222222222211111111110000000000
4799                                                                      10987654321098765432109876543210
4800                                                                      010001x0101xxxxx000100xxxxxxxxxx
4801                                                                      sqrdmlah.  */
4802                                                                   return 2208;
4803                                                                 }
4804                                                               else
4805                                                                 {
4806                                                                   /* 33222222222211111111110000000000
4807                                                                      10987654321098765432109876543210
4808                                                                      010001x0111xxxxx000100xxxxxxxxxx
4809                                                                      sqrdmlah.  */
4810                                                                   return 2209;
4811                                                                 }
4812                                                             }
4813                                                         }
4814                                                       else
4815                                                         {
4816                                                           if (((word >> 12) & 0x1) == 0)
4817                                                             {
4818                                                               if (((word >> 22) & 0x1) == 0)
4819                                                                 {
4820                                                                   /* 33222222222211111111110000000000
4821                                                                      10987654321098765432109876543210
4822                                                                      010001x0101xxxxx000010xxxxxxxxxx
4823                                                                      mla.  */
4824                                                                   return 2115;
4825                                                                 }
4826                                                               else
4827                                                                 {
4828                                                                   /* 33222222222211111111110000000000
4829                                                                      10987654321098765432109876543210
4830                                                                      010001x0111xxxxx000010xxxxxxxxxx
4831                                                                      mla.  */
4832                                                                   return 2116;
4833                                                                 }
4834                                                             }
4835                                                           else
4836                                                             {
4837                                                               /* 33222222222211111111110000000000
4838                                                                  10987654321098765432109876543210
4839                                                                  010001x01x1xxxxx000110xxxxxxxxxx
4840                                                                  usdot.  */
4841                                                               return 2468;
4842                                                             }
4843                                                         }
4844                                                     }
4845                                                   else
4846                                                     {
4847                                                       if (((word >> 11) & 0x1) == 0)
4848                                                         {
4849                                                           if (((word >> 12) & 0x1) == 0)
4850                                                             {
4851                                                               if (((word >> 22) & 0x1) == 0)
4852                                                                 {
4853                                                                   /* 33222222222211111111110000000000
4854                                                                      10987654321098765432109876543210
4855                                                                      010001x0101xxxxx000001xxxxxxxxxx
4856                                                                      udot.  */
4857                                                                   return 1985;
4858                                                                 }
4859                                                               else
4860                                                                 {
4861                                                                   /* 33222222222211111111110000000000
4862                                                                      10987654321098765432109876543210
4863                                                                      010001x0111xxxxx000001xxxxxxxxxx
4864                                                                      udot.  */
4865                                                                   return 1986;
4866                                                                 }
4867                                                             }
4868                                                           else
4869                                                             {
4870                                                               if (((word >> 22) & 0x1) == 0)
4871                                                                 {
4872                                                                   /* 33222222222211111111110000000000
4873                                                                      10987654321098765432109876543210
4874                                                                      010001x0101xxxxx000101xxxxxxxxxx
4875                                                                      sqrdmlsh.  */
4876                                                                   return 2212;
4877                                                                 }
4878                                                               else
4879                                                                 {
4880                                                                   /* 33222222222211111111110000000000
4881                                                                      10987654321098765432109876543210
4882                                                                      010001x0111xxxxx000101xxxxxxxxxx
4883                                                                      sqrdmlsh.  */
4884                                                                   return 2213;
4885                                                                 }
4886                                                             }
4887                                                         }
4888                                                       else
4889                                                         {
4890                                                           if (((word >> 12) & 0x1) == 0)
4891                                                             {
4892                                                               if (((word >> 22) & 0x1) == 0)
4893                                                                 {
4894                                                                   /* 33222222222211111111110000000000
4895                                                                      10987654321098765432109876543210
4896                                                                      010001x0101xxxxx000011xxxxxxxxxx
4897                                                                      mls.  */
4898                                                                   return 2118;
4899                                                                 }
4900                                                               else
4901                                                                 {
4902                                                                   /* 33222222222211111111110000000000
4903                                                                      10987654321098765432109876543210
4904                                                                      010001x0111xxxxx000011xxxxxxxxxx
4905                                                                      mls.  */
4906                                                                   return 2119;
4907                                                                 }
4908                                                             }
4909                                                           else
4910                                                             {
4911                                                               /* 33222222222211111111110000000000
4912                                                                  10987654321098765432109876543210
4913                                                                  010001x01x1xxxxx000111xxxxxxxxxx
4914                                                                  sudot.  */
4915                                                               return 2469;
4916                                                             }
4917                                                         }
4918                                                     }
4919                                                 }
4920                                               else
4921                                                 {
4922                                                   /* 33222222222211111111110000000000
4923                                                      10987654321098765432109876543210
4924                                                      110001x01x1xxxxx000xxxxxxxxxxxxx
4925                                                      ld1sh.  */
4926                                                   return 1589;
4927                                                 }
4928                                             }
4929                                         }
4930                                     }
4931                                 }
4932                               else
4933                                 {
4934                                   if (((word >> 31) & 0x1) == 0)
4935                                     {
4936                                       if (((word >> 21) & 0x1) == 0)
4937                                         {
4938                                           if (((word >> 16) & 0x1) == 0)
4939                                             {
4940                                               if (((word >> 17) & 0x1) == 0)
4941                                                 {
4942                                                   if (((word >> 18) & 0x1) == 0)
4943                                                     {
4944                                                       if (((word >> 19) & 0x1) == 0)
4945                                                         {
4946                                                           if (((word >> 20) & 0x1) == 0)
4947                                                             {
4948                                                               /* 33222222222211111111110000000000
4949                                                                  10987654321098765432109876543210
4950                                                                  0x0001x0xx000000100xxxxxxxxxxxxx
4951                                                                  asr.  */
4952                                                               return 1307;
4953                                                             }
4954                                                           else
4955                                                             {
4956                                                               if (((word >> 30) & 0x1) == 0)
4957                                                                 {
4958                                                                   /* 33222222222211111111110000000000
4959                                                                      10987654321098765432109876543210
4960                                                                      000001x0xx010000100xxxxxxxxxxxxx
4961                                                                      asr.  */
4962                                                                   return 1305;
4963                                                                 }
4964                                                               else
4965                                                                 {
4966                                                                   /* 33222222222211111111110000000000
4967                                                                      10987654321098765432109876543210
4968                                                                      010001x0xx010000100xxxxxxxxxxxxx
4969                                                                      shadd.  */
4970                                                                   return 2148;
4971                                                                 }
4972                                                             }
4973                                                         }
4974                                                       else
4975                                                         {
4976                                                           if (((word >> 20) & 0x1) == 0)
4977                                                             {
4978                                                               /* 33222222222211111111110000000000
4979                                                                  10987654321098765432109876543210
4980                                                                  0x0001x0xx001000100xxxxxxxxxxxxx
4981                                                                  sqshl.  */
4982                                                               return 2226;
4983                                                             }
4984                                                           else
4985                                                             {
4986                                                               if (((word >> 30) & 0x1) == 0)
4987                                                                 {
4988                                                                   /* 33222222222211111111110000000000
4989                                                                      10987654321098765432109876543210
4990                                                                      000001x0xx011000100xxxxxxxxxxxxx
4991                                                                      asr.  */
4992                                                                   return 1306;
4993                                                                 }
4994                                                               else
4995                                                                 {
4996                                                                   /* 33222222222211111111110000000000
4997                                                                      10987654321098765432109876543210
4998                                                                      010001x0xx011000100xxxxxxxxxxxxx
4999                                                                      sqadd.  */
5000                                                                   return 2177;
5001                                                                 }
5002                                                             }
5003                                                         }
5004                                                     }
5005                                                   else
5006                                                     {
5007                                                       if (((word >> 19) & 0x1) == 0)
5008                                                         {
5009                                                           if (((word >> 20) & 0x1) == 0)
5010                                                             {
5011                                                               /* 33222222222211111111110000000000
5012                                                                  10987654321098765432109876543210
5013                                                                  0x0001x0xx000100100xxxxxxxxxxxxx
5014                                                                  asrd.  */
5015                                                               return 1308;
5016                                                             }
5017                                                           else
5018                                                             {
5019                                                               if (((word >> 30) & 0x1) == 0)
5020                                                                 {
5021                                                                   /* 33222222222211111111110000000000
5022                                                                      10987654321098765432109876543210
5023                                                                      000001x0xx010100100xxxxxxxxxxxxx
5024                                                                      asrr.  */
5025                                                                   return 1309;
5026                                                                 }
5027                                                               else
5028                                                                 {
5029                                                                   /* 33222222222211111111110000000000
5030                                                                      10987654321098765432109876543210
5031                                                                      010001x0xx010100100xxxxxxxxxxxxx
5032                                                                      srhadd.  */
5033                                                                   return 2239;
5034                                                                 }
5035                                                             }
5036                                                         }
5037                                                       else
5038                                                         {
5039                                                           if (((word >> 20) & 0x1) == 0)
5040                                                             {
5041                                                               if (((word >> 30) & 0x1) == 0)
5042                                                                 {
5043                                                                   /* 33222222222211111111110000000000
5044                                                                      10987654321098765432109876543210
5045                                                                      000001x0xx001100100xxxxxxxxxxxxx
5046                                                                      srshr.  */
5047                                                                   return 2243;
5048                                                                 }
5049                                                               else
5050                                                                 {
5051                                                                   /* 33222222222211111111110000000000
5052                                                                      10987654321098765432109876543210
5053                                                                      010001x0xx001100100xxxxxxxxxxxxx
5054                                                                      sqshlr.  */
5055                                                                   return 2227;
5056                                                                 }
5057                                                             }
5058                                                           else
5059                                                             {
5060                                                               /* 33222222222211111111110000000000
5061                                                                  10987654321098765432109876543210
5062                                                                  0x0001x0xx011100100xxxxxxxxxxxxx
5063                                                                  suqadd.  */
5064                                                               return 2263;
5065                                                             }
5066                                                         }
5067                                                     }
5068                                                 }
5069                                               else
5070                                                 {
5071                                                   if (((word >> 18) & 0x1) == 0)
5072                                                     {
5073                                                       if (((word >> 19) & 0x1) == 0)
5074                                                         {
5075                                                           if (((word >> 20) & 0x1) == 0)
5076                                                             {
5077                                                               /* 33222222222211111111110000000000
5078                                                                  10987654321098765432109876543210
5079                                                                  0x0001x0xx000010100xxxxxxxxxxxxx
5080                                                                  srshl.  */
5081                                                               return 2241;
5082                                                             }
5083                                                           else
5084                                                             {
5085                                                               /* 33222222222211111111110000000000
5086                                                                  10987654321098765432109876543210
5087                                                                  0x0001x0xx010010100xxxxxxxxxxxxx
5088                                                                  shsub.  */
5089                                                               return 2151;
5090                                                             }
5091                                                         }
5092                                                       else
5093                                                         {
5094                                                           if (((word >> 20) & 0x1) == 0)
5095                                                             {
5096                                                               /* 33222222222211111111110000000000
5097                                                                  10987654321098765432109876543210
5098                                                                  0x0001x0xx001010100xxxxxxxxxxxxx
5099                                                                  sqrshl.  */
5100                                                               return 2219;
5101                                                             }
5102                                                           else
5103                                                             {
5104                                                               /* 33222222222211111111110000000000
5105                                                                  10987654321098765432109876543210
5106                                                                  0x0001x0xx011010100xxxxxxxxxxxxx
5107                                                                  sqsub.  */
5108                                                               return 2233;
5109                                                             }
5110                                                         }
5111                                                     }
5112                                                   else
5113                                                     {
5114                                                       if (((word >> 19) & 0x1) == 0)
5115                                                         {
5116                                                           if (((word >> 20) & 0x1) == 0)
5117                                                             {
5118                                                               if (((word >> 30) & 0x1) == 0)
5119                                                                 {
5120                                                                   /* 33222222222211111111110000000000
5121                                                                      10987654321098765432109876543210
5122                                                                      000001x0xx000110100xxxxxxxxxxxxx
5123                                                                      sqshl.  */
5124                                                                   return 2225;
5125                                                                 }
5126                                                               else
5127                                                                 {
5128                                                                   /* 33222222222211111111110000000000
5129                                                                      10987654321098765432109876543210
5130                                                                      010001x0xx000110100xxxxxxxxxxxxx
5131                                                                      srshlr.  */
5132                                                                   return 2242;
5133                                                                 }
5134                                                             }
5135                                                           else
5136                                                             {
5137                                                               /* 33222222222211111111110000000000
5138                                                                  10987654321098765432109876543210
5139                                                                  0x0001x0xx010110100xxxxxxxxxxxxx
5140                                                                  shsubr.  */
5141                                                               return 2152;
5142                                                             }
5143                                                         }
5144                                                       else
5145                                                         {
5146                                                           if (((word >> 20) & 0x1) == 0)
5147                                                             {
5148                                                               /* 33222222222211111111110000000000
5149                                                                  10987654321098765432109876543210
5150                                                                  0x0001x0xx001110100xxxxxxxxxxxxx
5151                                                                  sqrshlr.  */
5152                                                               return 2220;
5153                                                             }
5154                                                           else
5155                                                             {
5156                                                               /* 33222222222211111111110000000000
5157                                                                  10987654321098765432109876543210
5158                                                                  0x0001x0xx011110100xxxxxxxxxxxxx
5159                                                                  sqsubr.  */
5160                                                               return 2234;
5161                                                             }
5162                                                         }
5163                                                     }
5164                                                 }
5165                                             }
5166                                           else
5167                                             {
5168                                               if (((word >> 17) & 0x1) == 0)
5169                                                 {
5170                                                   if (((word >> 18) & 0x1) == 0)
5171                                                     {
5172                                                       if (((word >> 19) & 0x1) == 0)
5173                                                         {
5174                                                           if (((word >> 20) & 0x1) == 0)
5175                                                             {
5176                                                               /* 33222222222211111111110000000000
5177                                                                  10987654321098765432109876543210
5178                                                                  0x0001x0xx000001100xxxxxxxxxxxxx
5179                                                                  lsr.  */
5180                                                               return 1751;
5181                                                             }
5182                                                           else
5183                                                             {
5184                                                               if (((word >> 30) & 0x1) == 0)
5185                                                                 {
5186                                                                   /* 33222222222211111111110000000000
5187                                                                      10987654321098765432109876543210
5188                                                                      000001x0xx010001100xxxxxxxxxxxxx
5189                                                                      lsr.  */
5190                                                                   return 1749;
5191                                                                 }
5192                                                               else
5193                                                                 {
5194                                                                   /* 33222222222211111111110000000000
5195                                                                      10987654321098765432109876543210
5196                                                                      010001x0xx010001100xxxxxxxxxxxxx
5197                                                                      uhadd.  */
5198                                                                   return 2276;
5199                                                                 }
5200                                                             }
5201                                                         }
5202                                                       else
5203                                                         {
5204                                                           if (((word >> 20) & 0x1) == 0)
5205                                                             {
5206                                                               /* 33222222222211111111110000000000
5207                                                                  10987654321098765432109876543210
5208                                                                  0x0001x0xx001001100xxxxxxxxxxxxx
5209                                                                  uqshl.  */
5210                                                               return 2306;
5211                                                             }
5212                                                           else
5213                                                             {
5214                                                               if (((word >> 30) & 0x1) == 0)
5215                                                                 {
5216                                                                   /* 33222222222211111111110000000000
5217                                                                      10987654321098765432109876543210
5218                                                                      000001x0xx011001100xxxxxxxxxxxxx
5219                                                                      lsr.  */
5220                                                                   return 1750;
5221                                                                 }
5222                                                               else
5223                                                                 {
5224                                                                   /* 33222222222211111111110000000000
5225                                                                      10987654321098765432109876543210
5226                                                                      010001x0xx011001100xxxxxxxxxxxxx
5227                                                                      uqadd.  */
5228                                                                   return 2300;
5229                                                                 }
5230                                                             }
5231                                                         }
5232                                                     }
5233                                                   else
5234                                                     {
5235                                                       if (((word >> 19) & 0x1) == 0)
5236                                                         {
5237                                                           if (((word >> 30) & 0x1) == 0)
5238                                                             {
5239                                                               /* 33222222222211111111110000000000
5240                                                                  10987654321098765432109876543210
5241                                                                  000001x0xx0x0101100xxxxxxxxxxxxx
5242                                                                  lsrr.  */
5243                                                               return 1752;
5244                                                             }
5245                                                           else
5246                                                             {
5247                                                               /* 33222222222211111111110000000000
5248                                                                  10987654321098765432109876543210
5249                                                                  010001x0xx0x0101100xxxxxxxxxxxxx
5250                                                                  urhadd.  */
5251                                                               return 2315;
5252                                                             }
5253                                                         }
5254                                                       else
5255                                                         {
5256                                                           if (((word >> 20) & 0x1) == 0)
5257                                                             {
5258                                                               if (((word >> 30) & 0x1) == 0)
5259                                                                 {
5260                                                                   /* 33222222222211111111110000000000
5261                                                                      10987654321098765432109876543210
5262                                                                      000001x0xx001101100xxxxxxxxxxxxx
5263                                                                      urshr.  */
5264                                                                   return 2318;
5265                                                                 }
5266                                                               else
5267                                                                 {
5268                                                                   /* 33222222222211111111110000000000
5269                                                                      10987654321098765432109876543210
5270                                                                      010001x0xx001101100xxxxxxxxxxxxx
5271                                                                      uqshlr.  */
5272                                                                   return 2307;
5273                                                                 }
5274                                                             }
5275                                                           else
5276                                                             {
5277                                                               /* 33222222222211111111110000000000
5278                                                                  10987654321098765432109876543210
5279                                                                  0x0001x0xx011101100xxxxxxxxxxxxx
5280                                                                  usqadd.  */
5281                                                               return 2323;
5282                                                             }
5283                                                         }
5284                                                     }
5285                                                 }
5286                                               else
5287                                                 {
5288                                                   if (((word >> 18) & 0x1) == 0)
5289                                                     {
5290                                                       if (((word >> 19) & 0x1) == 0)
5291                                                         {
5292                                                           if (((word >> 20) & 0x1) == 0)
5293                                                             {
5294                                                               if (((word >> 30) & 0x1) == 0)
5295                                                                 {
5296                                                                   /* 33222222222211111111110000000000
5297                                                                      10987654321098765432109876543210
5298                                                                      000001x0xx000011100xxxxxxxxxxxxx
5299                                                                      lsl.  */
5300                                                                   return 1745;
5301                                                                 }
5302                                                               else
5303                                                                 {
5304                                                                   /* 33222222222211111111110000000000
5305                                                                      10987654321098765432109876543210
5306                                                                      010001x0xx000011100xxxxxxxxxxxxx
5307                                                                      urshl.  */
5308                                                                   return 2316;
5309                                                                 }
5310                                                             }
5311                                                           else
5312                                                             {
5313                                                               if (((word >> 30) & 0x1) == 0)
5314                                                                 {
5315                                                                   /* 33222222222211111111110000000000
5316                                                                      10987654321098765432109876543210
5317                                                                      000001x0xx010011100xxxxxxxxxxxxx
5318                                                                      lsl.  */
5319                                                                   return 1743;
5320                                                                 }
5321                                                               else
5322                                                                 {
5323                                                                   /* 33222222222211111111110000000000
5324                                                                      10987654321098765432109876543210
5325                                                                      010001x0xx010011100xxxxxxxxxxxxx
5326                                                                      uhsub.  */
5327                                                                   return 2277;
5328                                                                 }
5329                                                             }
5330                                                         }
5331                                                       else
5332                                                         {
5333                                                           if (((word >> 20) & 0x1) == 0)
5334                                                             {
5335                                                               /* 33222222222211111111110000000000
5336                                                                  10987654321098765432109876543210
5337                                                                  0x0001x0xx001011100xxxxxxxxxxxxx
5338                                                                  uqrshl.  */
5339                                                               return 2301;
5340                                                             }
5341                                                           else
5342                                                             {
5343                                                               if (((word >> 30) & 0x1) == 0)
5344                                                                 {
5345                                                                   /* 33222222222211111111110000000000
5346                                                                      10987654321098765432109876543210
5347                                                                      000001x0xx011011100xxxxxxxxxxxxx
5348                                                                      lsl.  */
5349                                                                   return 1744;
5350                                                                 }
5351                                                               else
5352                                                                 {
5353                                                                   /* 33222222222211111111110000000000
5354                                                                      10987654321098765432109876543210
5355                                                                      010001x0xx011011100xxxxxxxxxxxxx
5356                                                                      uqsub.  */
5357                                                                   return 2310;
5358                                                                 }
5359                                                             }
5360                                                         }
5361                                                     }
5362                                                   else
5363                                                     {
5364                                                       if (((word >> 19) & 0x1) == 0)
5365                                                         {
5366                                                           if (((word >> 20) & 0x1) == 0)
5367                                                             {
5368                                                               if (((word >> 30) & 0x1) == 0)
5369                                                                 {
5370                                                                   /* 33222222222211111111110000000000
5371                                                                      10987654321098765432109876543210
5372                                                                      000001x0xx000111100xxxxxxxxxxxxx
5373                                                                      uqshl.  */
5374                                                                   return 2305;
5375                                                                 }
5376                                                               else
5377                                                                 {
5378                                                                   /* 33222222222211111111110000000000
5379                                                                      10987654321098765432109876543210
5380                                                                      010001x0xx000111100xxxxxxxxxxxxx
5381                                                                      urshlr.  */
5382                                                                   return 2317;
5383                                                                 }
5384                                                             }
5385                                                           else
5386                                                             {
5387                                                               if (((word >> 30) & 0x1) == 0)
5388                                                                 {
5389                                                                   /* 33222222222211111111110000000000
5390                                                                      10987654321098765432109876543210
5391                                                                      000001x0xx010111100xxxxxxxxxxxxx
5392                                                                      lslr.  */
5393                                                                   return 1746;
5394                                                                 }
5395                                                               else
5396                                                                 {
5397                                                                   /* 33222222222211111111110000000000
5398                                                                      10987654321098765432109876543210
5399                                                                      010001x0xx010111100xxxxxxxxxxxxx
5400                                                                      uhsubr.  */
5401                                                                   return 2278;
5402                                                                 }
5403                                                             }
5404                                                         }
5405                                                       else
5406                                                         {
5407                                                           if (((word >> 20) & 0x1) == 0)
5408                                                             {
5409                                                               if (((word >> 30) & 0x1) == 0)
5410                                                                 {
5411                                                                   /* 33222222222211111111110000000000
5412                                                                      10987654321098765432109876543210
5413                                                                      000001x0xx001111100xxxxxxxxxxxxx
5414                                                                      sqshlu.  */
5415                                                                   return 2228;
5416                                                                 }
5417                                                               else
5418                                                                 {
5419                                                                   /* 33222222222211111111110000000000
5420                                                                      10987654321098765432109876543210
5421                                                                      010001x0xx001111100xxxxxxxxxxxxx
5422                                                                      uqrshlr.  */
5423                                                                   return 2302;
5424                                                                 }
5425                                                             }
5426                                                           else
5427                                                             {
5428                                                               /* 33222222222211111111110000000000
5429                                                                  10987654321098765432109876543210
5430                                                                  0x0001x0xx011111100xxxxxxxxxxxxx
5431                                                                  uqsubr.  */
5432                                                               return 2311;
5433                                                             }
5434                                                         }
5435                                                     }
5436                                                 }
5437                                             }
5438                                         }
5439                                       else
5440                                         {
5441                                           if (((word >> 10) & 0x1) == 0)
5442                                             {
5443                                               if (((word >> 12) & 0x1) == 0)
5444                                                 {
5445                                                   if (((word >> 30) & 0x1) == 0)
5446                                                     {
5447                                                       /* 33222222222211111111110000000000
5448                                                          10987654321098765432109876543210
5449                                                          000001x0xx1xxxxx1000x0xxxxxxxxxx
5450                                                          asr.  */
5451                                                       return 1303;
5452                                                     }
5453                                                   else
5454                                                     {
5455                                                       if (((word >> 22) & 0x1) == 0)
5456                                                         {
5457                                                           /* 33222222222211111111110000000000
5458                                                              10987654321098765432109876543210
5459                                                              010001x0x01xxxxx1000x0xxxxxxxxxx
5460                                                              smlalb.  */
5461                                                           return 2156;
5462                                                         }
5463                                                       else
5464                                                         {
5465                                                           /* 33222222222211111111110000000000
5466                                                              10987654321098765432109876543210
5467                                                              010001x0x11xxxxx1000x0xxxxxxxxxx
5468                                                              smlalb.  */
5469                                                           return 2157;
5470                                                         }
5471                                                     }
5472                                                 }
5473                                               else
5474                                                 {
5475                                                   if (((word >> 30) & 0x1) == 0)
5476                                                     {
5477                                                       /* 33222222222211111111110000000000
5478                                                          10987654321098765432109876543210
5479                                                          000001x0xx1xxxxx1001x0xxxxxxxxxx
5480                                                          asr.  */
5481                                                       return 1304;
5482                                                     }
5483                                                   else
5484                                                     {
5485                                                       if (((word >> 22) & 0x1) == 0)
5486                                                         {
5487                                                           /* 33222222222211111111110000000000
5488                                                              10987654321098765432109876543210
5489                                                              010001x0x01xxxxx1001x0xxxxxxxxxx
5490                                                              umlalb.  */
5491                                                           return 2281;
5492                                                         }
5493                                                       else
5494                                                         {
5495                                                           /* 33222222222211111111110000000000
5496                                                              10987654321098765432109876543210
5497                                                              010001x0x11xxxxx1001x0xxxxxxxxxx
5498                                                              umlalb.  */
5499                                                           return 2282;
5500                                                         }
5501                                                     }
5502                                                 }
5503                                             }
5504                                           else
5505                                             {
5506                                               if (((word >> 12) & 0x1) == 0)
5507                                                 {
5508                                                   if (((word >> 30) & 0x1) == 0)
5509                                                     {
5510                                                       if (((word >> 11) & 0x1) == 0)
5511                                                         {
5512                                                           /* 33222222222211111111110000000000
5513                                                              10987654321098765432109876543210
5514                                                              000001x0xx1xxxxx100001xxxxxxxxxx
5515                                                              lsr.  */
5516                                                           return 1747;
5517                                                         }
5518                                                       else
5519                                                         {
5520                                                           /* 33222222222211111111110000000000
5521                                                              10987654321098765432109876543210
5522                                                              000001x0xx1xxxxx100011xxxxxxxxxx
5523                                                              lsl.  */
5524                                                           return 1741;
5525                                                         }
5526                                                     }
5527                                                   else
5528                                                     {
5529                                                       if (((word >> 22) & 0x1) == 0)
5530                                                         {
5531                                                           /* 33222222222211111111110000000000
5532                                                              10987654321098765432109876543210
5533                                                              010001x0x01xxxxx1000x1xxxxxxxxxx
5534                                                              smlalt.  */
5535                                                           return 2159;
5536                                                         }
5537                                                       else
5538                                                         {
5539                                                           /* 33222222222211111111110000000000
5540                                                              10987654321098765432109876543210
5541                                                              010001x0x11xxxxx1000x1xxxxxxxxxx
5542                                                              smlalt.  */
5543                                                           return 2160;
5544                                                         }
5545                                                     }
5546                                                 }
5547                                               else
5548                                                 {
5549                                                   if (((word >> 30) & 0x1) == 0)
5550                                                     {
5551                                                       if (((word >> 11) & 0x1) == 0)
5552                                                         {
5553                                                           /* 33222222222211111111110000000000
5554                                                              10987654321098765432109876543210
5555                                                              000001x0xx1xxxxx100101xxxxxxxxxx
5556                                                              lsr.  */
5557                                                           return 1748;
5558                                                         }
5559                                                       else
5560                                                         {
5561                                                           /* 33222222222211111111110000000000
5562                                                              10987654321098765432109876543210
5563                                                              000001x0xx1xxxxx100111xxxxxxxxxx
5564                                                              lsl.  */
5565                                                           return 1742;
5566                                                         }
5567                                                     }
5568                                                   else
5569                                                     {
5570                                                       if (((word >> 22) & 0x1) == 0)
5571                                                         {
5572                                                           /* 33222222222211111111110000000000
5573                                                              10987654321098765432109876543210
5574                                                              010001x0x01xxxxx1001x1xxxxxxxxxx
5575                                                              umlalt.  */
5576                                                           return 2284;
5577                                                         }
5578                                                       else
5579                                                         {
5580                                                           /* 33222222222211111111110000000000
5581                                                              10987654321098765432109876543210
5582                                                              010001x0x11xxxxx1001x1xxxxxxxxxx
5583                                                              umlalt.  */
5584                                                           return 2285;
5585                                                         }
5586                                                     }
5587                                                 }
5588                                             }
5589                                         }
5590                                     }
5591                                   else
5592                                     {
5593                                       if (((word >> 22) & 0x1) == 0)
5594                                         {
5595                                           if (((word >> 21) & 0x1) == 0)
5596                                             {
5597                                               if (((word >> 23) & 0x1) == 0)
5598                                                 {
5599                                                   /* 33222222222211111111110000000000
5600                                                      10987654321098765432109876543210
5601                                                      1x0001x0000xxxxx100xxxxxxxxxxxxx
5602                                                      ldnt1sb.  */
5603                                                   return 2108;
5604                                                 }
5605                                               else
5606                                                 {
5607                                                   /* 33222222222211111111110000000000
5608                                                      10987654321098765432109876543210
5609                                                      1x0001x0100xxxxx100xxxxxxxxxxxxx
5610                                                      ldnt1sh.  */
5611                                                   return 2109;
5612                                                 }
5613                                             }
5614                                           else
5615                                             {
5616                                               if (((word >> 23) & 0x1) == 0)
5617                                                 {
5618                                                   if (((word >> 30) & 0x1) == 0)
5619                                                     {
5620                                                       /* 33222222222211111111110000000000
5621                                                          10987654321098765432109876543210
5622                                                          100001x0001xxxxx100xxxxxxxxxxxxx
5623                                                          ld1sb.  */
5624                                                       return 1579;
5625                                                     }
5626                                                   else
5627                                                     {
5628                                                       /* 33222222222211111111110000000000
5629                                                          10987654321098765432109876543210
5630                                                          110001x0001xxxxx100xxxxxxxxxxxxx
5631                                                          ld1sb.  */
5632                                                       return 1583;
5633                                                     }
5634                                                 }
5635                                               else
5636                                                 {
5637                                                   if (((word >> 30) & 0x1) == 0)
5638                                                     {
5639                                                       /* 33222222222211111111110000000000
5640                                                          10987654321098765432109876543210
5641                                                          100001x0101xxxxx100xxxxxxxxxxxxx
5642                                                          ld1sh.  */
5643                                                       return 1592;
5644                                                     }
5645                                                   else
5646                                                     {
5647                                                       /* 33222222222211111111110000000000
5648                                                          10987654321098765432109876543210
5649                                                          110001x0101xxxxx100xxxxxxxxxxxxx
5650                                                          ld1sh.  */
5651                                                       return 1595;
5652                                                     }
5653                                                 }
5654                                             }
5655                                         }
5656                                       else
5657                                         {
5658                                           if (((word >> 23) & 0x1) == 0)
5659                                             {
5660                                               if (((word >> 30) & 0x1) == 0)
5661                                                 {
5662                                                   /* 33222222222211111111110000000000
5663                                                      10987654321098765432109876543210
5664                                                      100001x001xxxxxx100xxxxxxxxxxxxx
5665                                                      ld1rb.  */
5666                                                   return 1549;
5667                                                 }
5668                                               else
5669                                                 {
5670                                                   if (((word >> 21) & 0x1) == 0)
5671                                                     {
5672                                                       /* 33222222222211111111110000000000
5673                                                          10987654321098765432109876543210
5674                                                          110001x0010xxxxx100xxxxxxxxxxxxx
5675                                                          ld1sb.  */
5676                                                       return 1578;
5677                                                     }
5678                                                   else
5679                                                     {
5680                                                       /* 33222222222211111111110000000000
5681                                                          10987654321098765432109876543210
5682                                                          110001x0011xxxxx100xxxxxxxxxxxxx
5683                                                          prfb.  */
5684                                                       return 1781;
5685                                                     }
5686                                                 }
5687                                             }
5688                                           else
5689                                             {
5690                                               if (((word >> 30) & 0x1) == 0)
5691                                                 {
5692                                                   /* 33222222222211111111110000000000
5693                                                      10987654321098765432109876543210
5694                                                      100001x011xxxxxx100xxxxxxxxxxxxx
5695                                                      ld1rsw.  */
5696                                                   return 1570;
5697                                                 }
5698                                               else
5699                                                 {
5700                                                   if (((word >> 21) & 0x1) == 0)
5701                                                     {
5702                                                       /* 33222222222211111111110000000000
5703                                                          10987654321098765432109876543210
5704                                                          110001x0110xxxxx100xxxxxxxxxxxxx
5705                                                          ld1sh.  */
5706                                                       return 1590;
5707                                                     }
5708                                                   else
5709                                                     {
5710                                                       /* 33222222222211111111110000000000
5711                                                          10987654321098765432109876543210
5712                                                          110001x0111xxxxx100xxxxxxxxxxxxx
5713                                                          ld1sh.  */
5714                                                       return 1591;
5715                                                     }
5716                                                 }
5717                                             }
5718                                         }
5719                                     }
5720                                 }
5721                             }
5722                           else
5723                             {
5724                               if (((word >> 15) & 0x1) == 0)
5725                                 {
5726                                   if (((word >> 21) & 0x1) == 0)
5727                                     {
5728                                       if (((word >> 30) & 0x1) == 0)
5729                                         {
5730                                           if (((word >> 31) & 0x1) == 0)
5731                                             {
5732                                               /* 33222222222211111111110000000000
5733                                                  10987654321098765432109876543210
5734                                                  000001x0xx0xxxxx010xxxxxxxxxxxxx
5735                                                  mla.  */
5736                                               return 1754;
5737                                             }
5738                                           else
5739                                             {
5740                                               if (((word >> 23) & 0x1) == 0)
5741                                                 {
5742                                                   /* 33222222222211111111110000000000
5743                                                      10987654321098765432109876543210
5744                                                      100001x00x0xxxxx010xxxxxxxxxxxxx
5745                                                      ld1b.  */
5746                                                   return 1515;
5747                                                 }
5748                                               else
5749                                                 {
5750                                                   /* 33222222222211111111110000000000
5751                                                      10987654321098765432109876543210
5752                                                      100001x01x0xxxxx010xxxxxxxxxxxxx
5753                                                      ld1h.  */
5754                                                   return 1535;
5755                                                 }
5756                                             }
5757                                         }
5758                                       else
5759                                         {
5760                                           if (((word >> 31) & 0x1) == 0)
5761                                             {
5762                                               if (((word >> 10) & 0x1) == 0)
5763                                                 {
5764                                                   if (((word >> 11) & 0x1) == 0)
5765                                                     {
5766                                                       if (((word >> 12) & 0x1) == 0)
5767                                                         {
5768                                                           /* 33222222222211111111110000000000
5769                                                              10987654321098765432109876543210
5770                                                              010001x0xx0xxxxx010000xxxxxxxxxx
5771                                                              smlalb.  */
5772                                                           return 2158;
5773                                                         }
5774                                                       else
5775                                                         {
5776                                                           /* 33222222222211111111110000000000
5777                                                              10987654321098765432109876543210
5778                                                              010001x0xx0xxxxx010100xxxxxxxxxx
5779                                                              smlslb.  */
5780                                                           return 2164;
5781                                                         }
5782                                                     }
5783                                                   else
5784                                                     {
5785                                                       if (((word >> 12) & 0x1) == 0)
5786                                                         {
5787                                                           /* 33222222222211111111110000000000
5788                                                              10987654321098765432109876543210
5789                                                              010001x0xx0xxxxx010010xxxxxxxxxx
5790                                                              umlalb.  */
5791                                                           return 2283;
5792                                                         }
5793                                                       else
5794                                                         {
5795                                                           /* 33222222222211111111110000000000
5796                                                              10987654321098765432109876543210
5797                                                              010001x0xx0xxxxx010110xxxxxxxxxx
5798                                                              umlslb.  */
5799                                                           return 2289;
5800                                                         }
5801                                                     }
5802                                                 }
5803                                               else
5804                                                 {
5805                                                   if (((word >> 11) & 0x1) == 0)
5806                                                     {
5807                                                       if (((word >> 12) & 0x1) == 0)
5808                                                         {
5809                                                           /* 33222222222211111111110000000000
5810                                                              10987654321098765432109876543210
5811                                                              010001x0xx0xxxxx010001xxxxxxxxxx
5812                                                              smlalt.  */
5813                                                           return 2161;
5814                                                         }
5815                                                       else
5816                                                         {
5817                                                           /* 33222222222211111111110000000000
5818                                                              10987654321098765432109876543210
5819                                                              010001x0xx0xxxxx010101xxxxxxxxxx
5820                                                              smlslt.  */
5821                                                           return 2167;
5822                                                         }
5823                                                     }
5824                                                   else
5825                                                     {
5826                                                       if (((word >> 12) & 0x1) == 0)
5827                                                         {
5828                                                           /* 33222222222211111111110000000000
5829                                                              10987654321098765432109876543210
5830                                                              010001x0xx0xxxxx010011xxxxxxxxxx
5831                                                              umlalt.  */
5832                                                           return 2286;
5833                                                         }
5834                                                       else
5835                                                         {
5836                                                           /* 33222222222211111111110000000000
5837                                                              10987654321098765432109876543210
5838                                                              010001x0xx0xxxxx010111xxxxxxxxxx
5839                                                              umlslt.  */
5840                                                           return 2292;
5841                                                         }
5842                                                     }
5843                                                 }
5844                                             }
5845                                           else
5846                                             {
5847                                               if (((word >> 23) & 0x1) == 0)
5848                                                 {
5849                                                   /* 33222222222211111111110000000000
5850                                                      10987654321098765432109876543210
5851                                                      110001x00x0xxxxx010xxxxxxxxxxxxx
5852                                                      ld1b.  */
5853                                                   return 1520;
5854                                                 }
5855                                               else
5856                                                 {
5857                                                   /* 33222222222211111111110000000000
5858                                                      10987654321098765432109876543210
5859                                                      110001x01x0xxxxx010xxxxxxxxxxxxx
5860                                                      ld1h.  */
5861                                                   return 1540;
5862                                                 }
5863                                             }
5864                                         }
5865                                     }
5866                                   else
5867                                     {
5868                                       if (((word >> 30) & 0x1) == 0)
5869                                         {
5870                                           if (((word >> 31) & 0x1) == 0)
5871                                             {
5872                                               if (((word >> 11) & 0x1) == 0)
5873                                                 {
5874                                                   if (((word >> 12) & 0x1) == 0)
5875                                                     {
5876                                                       if (((word >> 10) & 0x1) == 0)
5877                                                         {
5878                                                           /* 33222222222211111111110000000000
5879                                                              10987654321098765432109876543210
5880                                                              000001x0xx1xxxxx010000xxxxxxxxxx
5881                                                              index.  */
5882                                                           return 1506;
5883                                                         }
5884                                                       else
5885                                                         {
5886                                                           /* 33222222222211111111110000000000
5887                                                              10987654321098765432109876543210
5888                                                              000001x0xx1xxxxx010001xxxxxxxxxx
5889                                                              index.  */
5890                                                           return 1507;
5891                                                         }
5892                                                     }
5893                                                   else
5894                                                     {
5895                                                       if (((word >> 22) & 0x1) == 0)
5896                                                         {
5897                                                           if (((word >> 23) & 0x1) == 0)
5898                                                             {
5899                                                               /* 33222222222211111111110000000000
5900                                                                  10987654321098765432109876543210
5901                                                                  000001x0001xxxxx01010xxxxxxxxxxx
5902                                                                  addvl.  */
5903                                                               return 1293;
5904                                                             }
5905                                                           else
5906                                                             {
5907                                                               /* 33222222222211111111110000000000
5908                                                                  10987654321098765432109876543210
5909                                                                  000001x0101xxxxx01010xxxxxxxxxxx
5910                                                                  rdvl.  */
5911                                                               return 1815;
5912                                                             }
5913                                                         }
5914                                                       else
5915                                                         {
5916                                                           /* 33222222222211111111110000000000
5917                                                              10987654321098765432109876543210
5918                                                              000001x0x11xxxxx01010xxxxxxxxxxx
5919                                                              addpl.  */
5920                                                           return 1292;
5921                                                         }
5922                                                     }
5923                                                 }
5924                                               else
5925                                                 {
5926                                                   if (((word >> 10) & 0x1) == 0)
5927                                                     {
5928                                                       /* 33222222222211111111110000000000
5929                                                          10987654321098765432109876543210
5930                                                          000001x0xx1xxxxx010x10xxxxxxxxxx
5931                                                          index.  */
5932                                                       return 1508;
5933                                                     }
5934                                                   else
5935                                                     {
5936                                                       /* 33222222222211111111110000000000
5937                                                          10987654321098765432109876543210
5938                                                          000001x0xx1xxxxx010x11xxxxxxxxxx
5939                                                          index.  */
5940                                                       return 1505;
5941                                                     }
5942                                                 }
5943                                             }
5944                                           else
5945                                             {
5946                                               if (((word >> 23) & 0x1) == 0)
5947                                                 {
5948                                                   /* 33222222222211111111110000000000
5949                                                      10987654321098765432109876543210
5950                                                      100001x00x1xxxxx010xxxxxxxxxxxxx
5951                                                      prfw.  */
5952                                                   return 1799;
5953                                                 }
5954                                               else
5955                                                 {
5956                                                   /* 33222222222211111111110000000000
5957                                                      10987654321098765432109876543210
5958                                                      100001x01x1xxxxx010xxxxxxxxxxxxx
5959                                                      ld1h.  */
5960                                                   return 1536;
5961                                                 }
5962                                             }
5963                                         }
5964                                       else
5965                                         {
5966                                           if (((word >> 23) & 0x1) == 0)
5967                                             {
5968                                               /* 33222222222211111111110000000000
5969                                                  10987654321098765432109876543210
5970                                                  x10001x00x1xxxxx010xxxxxxxxxxxxx
5971                                                  prfw.  */
5972                                               return 1801;
5973                                             }
5974                                           else
5975                                             {
5976                                               if (((word >> 31) & 0x1) == 0)
5977                                                 {
5978                                                   if (((word >> 22) & 0x1) == 0)
5979                                                     {
5980                                                       /* 33222222222211111111110000000000
5981                                                          10987654321098765432109876543210
5982                                                          010001x0101xxxxx010xxxxxxxxxxxxx
5983                                                          cdot.  */
5984                                                       return 2073;
5985                                                     }
5986                                                   else
5987                                                     {
5988                                                       /* 33222222222211111111110000000000
5989                                                          10987654321098765432109876543210
5990                                                          010001x0111xxxxx010xxxxxxxxxxxxx
5991                                                          cdot.  */
5992                                                       return 2072;
5993                                                     }
5994                                                 }
5995                                               else
5996                                                 {
5997                                                   /* 33222222222211111111110000000000
5998                                                      10987654321098765432109876543210
5999                                                      110001x01x1xxxxx010xxxxxxxxxxxxx
6000                                                      ld1h.  */
6001                                                   return 1541;
6002                                                 }
6003                                             }
6004                                         }
6005                                     }
6006                                 }
6007                               else
6008                                 {
6009                                   if (((word >> 30) & 0x1) == 0)
6010                                     {
6011                                       if (((word >> 31) & 0x1) == 0)
6012                                         {
6013                                           if (((word >> 21) & 0x1) == 0)
6014                                             {
6015                                               /* 33222222222211111111110000000000
6016                                                  10987654321098765432109876543210
6017                                                  000001x0xx0xxxxx110xxxxxxxxxxxxx
6018                                                  mad.  */
6019                                               return 1753;
6020                                             }
6021                                           else
6022                                             {
6023                                               if (((word >> 10) & 0x1) == 0)
6024                                                 {
6025                                                   if (((word >> 11) & 0x1) == 0)
6026                                                     {
6027                                                       if (((word >> 20) & 0x1) == 0)
6028                                                         {
6029                                                           if (((word >> 22) & 0x1) == 0)
6030                                                             {
6031                                                               /* 33222222222211111111110000000000
6032                                                                  10987654321098765432109876543210
6033                                                                  000001x0x010xxxx110x00xxxxxxxxxx
6034                                                                  sqincw.  */
6035                                                               return 1873;
6036                                                             }
6037                                                           else
6038                                                             {
6039                                                               if (((word >> 23) & 0x1) == 0)
6040                                                                 {
6041                                                                   /* 33222222222211111111110000000000
6042                                                                      10987654321098765432109876543210
6043                                                                      000001x00110xxxx110x00xxxxxxxxxx
6044                                                                      sqinch.  */
6045                                                                   return 1867;
6046                                                                 }
6047                                                               else
6048                                                                 {
6049                                                                   /* 33222222222211111111110000000000
6050                                                                      10987654321098765432109876543210
6051                                                                      000001x01110xxxx110x00xxxxxxxxxx
6052                                                                      sqincd.  */
6053                                                                   return 1864;
6054                                                                 }
6055                                                             }
6056                                                         }
6057                                                       else
6058                                                         {
6059                                                           if (((word >> 22) & 0x1) == 0)
6060                                                             {
6061                                                               /* 33222222222211111111110000000000
6062                                                                  10987654321098765432109876543210
6063                                                                  000001x0x011xxxx110x00xxxxxxxxxx
6064                                                                  incw.  */
6065                                                               return 1503;
6066                                                             }
6067                                                           else
6068                                                             {
6069                                                               if (((word >> 23) & 0x1) == 0)
6070                                                                 {
6071                                                                   /* 33222222222211111111110000000000
6072                                                                      10987654321098765432109876543210
6073                                                                      000001x00111xxxx110x00xxxxxxxxxx
6074                                                                      inch.  */
6075                                                                   return 1499;
6076                                                                 }
6077                                                               else
6078                                                                 {
6079                                                                   /* 33222222222211111111110000000000
6080                                                                      10987654321098765432109876543210
6081                                                                      000001x01111xxxx110x00xxxxxxxxxx
6082                                                                      incd.  */
6083                                                                   return 1497;
6084                                                                 }
6085                                                             }
6086                                                         }
6087                                                     }
6088                                                   else
6089                                                     {
6090                                                       if (((word >> 22) & 0x1) == 0)
6091                                                         {
6092                                                           /* 33222222222211111111110000000000
6093                                                              10987654321098765432109876543210
6094                                                              000001x0x01xxxxx110x10xxxxxxxxxx
6095                                                              sqdecw.  */
6096                                                           return 1859;
6097                                                         }
6098                                                       else
6099                                                         {
6100                                                           if (((word >> 23) & 0x1) == 0)
6101                                                             {
6102                                                               /* 33222222222211111111110000000000
6103                                                                  10987654321098765432109876543210
6104                                                                  000001x0011xxxxx110x10xxxxxxxxxx
6105                                                                  sqdech.  */
6106                                                               return 1853;
6107                                                             }
6108                                                           else
6109                                                             {
6110                                                               /* 33222222222211111111110000000000
6111                                                                  10987654321098765432109876543210
6112                                                                  000001x0111xxxxx110x10xxxxxxxxxx
6113                                                                  sqdecd.  */
6114                                                               return 1850;
6115                                                             }
6116                                                         }
6117                                                     }
6118                                                 }
6119                                               else
6120                                                 {
6121                                                   if (((word >> 11) & 0x1) == 0)
6122                                                     {
6123                                                       if (((word >> 20) & 0x1) == 0)
6124                                                         {
6125                                                           if (((word >> 22) & 0x1) == 0)
6126                                                             {
6127                                                               /* 33222222222211111111110000000000
6128                                                                  10987654321098765432109876543210
6129                                                                  000001x0x010xxxx110x01xxxxxxxxxx
6130                                                                  uqincw.  */
6131                                                               return 2021;
6132                                                             }
6133                                                           else
6134                                                             {
6135                                                               if (((word >> 23) & 0x1) == 0)
6136                                                                 {
6137                                                                   /* 33222222222211111111110000000000
6138                                                                      10987654321098765432109876543210
6139                                                                      000001x00110xxxx110x01xxxxxxxxxx
6140                                                                      uqinch.  */
6141                                                                   return 2015;
6142                                                                 }
6143                                                               else
6144                                                                 {
6145                                                                   /* 33222222222211111111110000000000
6146                                                                      10987654321098765432109876543210
6147                                                                      000001x01110xxxx110x01xxxxxxxxxx
6148                                                                      uqincd.  */
6149                                                                   return 2012;
6150                                                                 }
6151                                                             }
6152                                                         }
6153                                                       else
6154                                                         {
6155                                                           if (((word >> 22) & 0x1) == 0)
6156                                                             {
6157                                                               /* 33222222222211111111110000000000
6158                                                                  10987654321098765432109876543210
6159                                                                  000001x0x011xxxx110x01xxxxxxxxxx
6160                                                                  decw.  */
6161                                                               return 1378;
6162                                                             }
6163                                                           else
6164                                                             {
6165                                                               if (((word >> 23) & 0x1) == 0)
6166                                                                 {
6167                                                                   /* 33222222222211111111110000000000
6168                                                                      10987654321098765432109876543210
6169                                                                      000001x00111xxxx110x01xxxxxxxxxx
6170                                                                      dech.  */
6171                                                                   return 1374;
6172                                                                 }
6173                                                               else
6174                                                                 {
6175                                                                   /* 33222222222211111111110000000000
6176                                                                      10987654321098765432109876543210
6177                                                                      000001x01111xxxx110x01xxxxxxxxxx
6178                                                                      decd.  */
6179                                                                   return 1372;
6180                                                                 }
6181                                                             }
6182                                                         }
6183                                                     }
6184                                                   else
6185                                                     {
6186                                                       if (((word >> 22) & 0x1) == 0)
6187                                                         {
6188                                                           /* 33222222222211111111110000000000
6189                                                              10987654321098765432109876543210
6190                                                              000001x0x01xxxxx110x11xxxxxxxxxx
6191                                                              uqdecw.  */
6192                                                           return 2007;
6193                                                         }
6194                                                       else
6195                                                         {
6196                                                           if (((word >> 23) & 0x1) == 0)
6197                                                             {
6198                                                               /* 33222222222211111111110000000000
6199                                                                  10987654321098765432109876543210
6200                                                                  000001x0011xxxxx110x11xxxxxxxxxx
6201                                                                  uqdech.  */
6202                                                               return 2001;
6203                                                             }
6204                                                           else
6205                                                             {
6206                                                               /* 33222222222211111111110000000000
6207                                                                  10987654321098765432109876543210
6208                                                                  000001x0111xxxxx110x11xxxxxxxxxx
6209                                                                  uqdecd.  */
6210                                                               return 1998;
6211                                                             }
6212                                                         }
6213                                                     }
6214                                                 }
6215                                             }
6216                                         }
6217                                       else
6218                                         {
6219                                           if (((word >> 22) & 0x1) == 0)
6220                                             {
6221                                               if (((word >> 21) & 0x1) == 0)
6222                                                 {
6223                                                   if (((word >> 23) & 0x1) == 0)
6224                                                     {
6225                                                       /* 33222222222211111111110000000000
6226                                                          10987654321098765432109876543210
6227                                                          100001x0000xxxxx110xxxxxxxxxxxxx
6228                                                          prfb.  */
6229                                                       return 1778;
6230                                                     }
6231                                                   else
6232                                                     {
6233                                                       /* 33222222222211111111110000000000
6234                                                          10987654321098765432109876543210
6235                                                          100001x0100xxxxx110xxxxxxxxxxxxx
6236                                                          prfh.  */
6237                                                       return 1793;
6238                                                     }
6239                                                 }
6240                                               else
6241                                                 {
6242                                                   if (((word >> 23) & 0x1) == 0)
6243                                                     {
6244                                                       /* 33222222222211111111110000000000
6245                                                          10987654321098765432109876543210
6246                                                          100001x0001xxxxx110xxxxxxxxxxxxx
6247                                                          ld1b.  */
6248                                                       return 1522;
6249                                                     }
6250                                                   else
6251                                                     {
6252                                                       /* 33222222222211111111110000000000
6253                                                          10987654321098765432109876543210
6254                                                          100001x0101xxxxx110xxxxxxxxxxxxx
6255                                                          ld1h.  */
6256                                                       return 1544;
6257                                                     }
6258                                                 }
6259                                             }
6260                                           else
6261                                             {
6262                                               if (((word >> 23) & 0x1) == 0)
6263                                                 {
6264                                                   /* 33222222222211111111110000000000
6265                                                      10987654321098765432109876543210
6266                                                      100001x001xxxxxx110xxxxxxxxxxxxx
6267                                                      ld1rb.  */
6268                                                   return 1551;
6269                                                 }
6270                                               else
6271                                                 {
6272                                                   /* 33222222222211111111110000000000
6273                                                      10987654321098765432109876543210
6274                                                      100001x011xxxxxx110xxxxxxxxxxxxx
6275                                                      ld1rh.  */
6276                                                   return 1555;
6277                                                 }
6278                                             }
6279                                         }
6280                                     }
6281                                   else
6282                                     {
6283                                       if (((word >> 21) & 0x1) == 0)
6284                                         {
6285                                           if (((word >> 31) & 0x1) == 0)
6286                                             {
6287                                               if (((word >> 10) & 0x1) == 0)
6288                                                 {
6289                                                   /* 33222222222211111111110000000000
6290                                                      10987654321098765432109876543210
6291                                                      010001x0xx0xxxxx110xx0xxxxxxxxxx
6292                                                      sclamp.  */
6293                                                   return 2408;
6294                                                 }
6295                                               else
6296                                                 {
6297                                                   /* 33222222222211111111110000000000
6298                                                      10987654321098765432109876543210
6299                                                      010001x0xx0xxxxx110xx1xxxxxxxxxx
6300                                                      uclamp.  */
6301                                                   return 2409;
6302                                                 }
6303                                             }
6304                                           else
6305                                             {
6306                                               if (((word >> 22) & 0x1) == 0)
6307                                                 {
6308                                                   if (((word >> 23) & 0x1) == 0)
6309                                                     {
6310                                                       /* 33222222222211111111110000000000
6311                                                          10987654321098765432109876543210
6312                                                          110001x0000xxxxx110xxxxxxxxxxxxx
6313                                                          ldnt1b.  */
6314                                                       return 2104;
6315                                                     }
6316                                                   else
6317                                                     {
6318                                                       /* 33222222222211111111110000000000
6319                                                          10987654321098765432109876543210
6320                                                          110001x0100xxxxx110xxxxxxxxxxxxx
6321                                                          ldnt1h.  */
6322                                                       return 2107;
6323                                                     }
6324                                                 }
6325                                               else
6326                                                 {
6327                                                   if (((word >> 23) & 0x1) == 0)
6328                                                     {
6329                                                       /* 33222222222211111111110000000000
6330                                                          10987654321098765432109876543210
6331                                                          110001x0010xxxxx110xxxxxxxxxxxxx
6332                                                          ld1b.  */
6333                                                       return 1521;
6334                                                     }
6335                                                   else
6336                                                     {
6337                                                       /* 33222222222211111111110000000000
6338                                                          10987654321098765432109876543210
6339                                                          110001x0110xxxxx110xxxxxxxxxxxxx
6340                                                          ld1h.  */
6341                                                       return 1542;
6342                                                     }
6343                                                 }
6344                                             }
6345                                         }
6346                                       else
6347                                         {
6348                                           if (((word >> 22) & 0x1) == 0)
6349                                             {
6350                                               if (((word >> 23) & 0x1) == 0)
6351                                                 {
6352                                                   /* 33222222222211111111110000000000
6353                                                      10987654321098765432109876543210
6354                                                      x10001x0001xxxxx110xxxxxxxxxxxxx
6355                                                      ld1b.  */
6356                                                   return 1527;
6357                                                 }
6358                                               else
6359                                                 {
6360                                                   if (((word >> 31) & 0x1) == 0)
6361                                                     {
6362                                                       if (((word >> 10) & 0x1) == 0)
6363                                                         {
6364                                                           if (((word >> 12) & 0x1) == 0)
6365                                                             {
6366                                                               /* 33222222222211111111110000000000
6367                                                                  10987654321098765432109876543210
6368                                                                  010001x0101xxxxx1100x0xxxxxxxxxx
6369                                                                  smullb.  */
6370                                                               return 2169;
6371                                                             }
6372                                                           else
6373                                                             {
6374                                                               /* 33222222222211111111110000000000
6375                                                                  10987654321098765432109876543210
6376                                                                  010001x0101xxxxx1101x0xxxxxxxxxx
6377                                                                  umullb.  */
6378                                                               return 2294;
6379                                                             }
6380                                                         }
6381                                                       else
6382                                                         {
6383                                                           if (((word >> 12) & 0x1) == 0)
6384                                                             {
6385                                                               /* 33222222222211111111110000000000
6386                                                                  10987654321098765432109876543210
6387                                                                  010001x0101xxxxx1100x1xxxxxxxxxx
6388                                                                  smullt.  */
6389                                                               return 2172;
6390                                                             }
6391                                                           else
6392                                                             {
6393                                                               /* 33222222222211111111110000000000
6394                                                                  10987654321098765432109876543210
6395                                                                  010001x0101xxxxx1101x1xxxxxxxxxx
6396                                                                  umullt.  */
6397                                                               return 2297;
6398                                                             }
6399                                                         }
6400                                                     }
6401                                                   else
6402                                                     {
6403                                                       /* 33222222222211111111110000000000
6404                                                          10987654321098765432109876543210
6405                                                          110001x0101xxxxx110xxxxxxxxxxxxx
6406                                                          ld1h.  */
6407                                                       return 1548;
6408                                                     }
6409                                                 }
6410                                             }
6411                                           else
6412                                             {
6413                                               if (((word >> 23) & 0x1) == 0)
6414                                                 {
6415                                                   /* 33222222222211111111110000000000
6416                                                      10987654321098765432109876543210
6417                                                      x10001x0011xxxxx110xxxxxxxxxxxxx
6418                                                      prfw.  */
6419                                                   return 1802;
6420                                                 }
6421                                               else
6422                                                 {
6423                                                   if (((word >> 31) & 0x1) == 0)
6424                                                     {
6425                                                       if (((word >> 10) & 0x1) == 0)
6426                                                         {
6427                                                           if (((word >> 12) & 0x1) == 0)
6428                                                             {
6429                                                               /* 33222222222211111111110000000000
6430                                                                  10987654321098765432109876543210
6431                                                                  010001x0111xxxxx1100x0xxxxxxxxxx
6432                                                                  smullb.  */
6433                                                               return 2170;
6434                                                             }
6435                                                           else
6436                                                             {
6437                                                               /* 33222222222211111111110000000000
6438                                                                  10987654321098765432109876543210
6439                                                                  010001x0111xxxxx1101x0xxxxxxxxxx
6440                                                                  umullb.  */
6441                                                               return 2295;
6442                                                             }
6443                                                         }
6444                                                       else
6445                                                         {
6446                                                           if (((word >> 12) & 0x1) == 0)
6447                                                             {
6448                                                               /* 33222222222211111111110000000000
6449                                                                  10987654321098765432109876543210
6450                                                                  010001x0111xxxxx1100x1xxxxxxxxxx
6451                                                                  smullt.  */
6452                                                               return 2173;
6453                                                             }
6454                                                           else
6455                                                             {
6456                                                               /* 33222222222211111111110000000000
6457                                                                  10987654321098765432109876543210
6458                                                                  010001x0111xxxxx1101x1xxxxxxxxxx
6459                                                                  umullt.  */
6460                                                               return 2298;
6461                                                             }
6462                                                         }
6463                                                     }
6464                                                   else
6465                                                     {
6466                                                       /* 33222222222211111111110000000000
6467                                                          10987654321098765432109876543210
6468                                                          110001x0111xxxxx110xxxxxxxxxxxxx
6469                                                          ld1h.  */
6470                                                       return 1543;
6471                                                     }
6472                                                 }
6473                                             }
6474                                         }
6475                                     }
6476                                 }
6477                             }
6478                         }
6479                       else
6480                         {
6481                           if (((word >> 14) & 0x1) == 0)
6482                             {
6483                               if (((word >> 15) & 0x1) == 0)
6484                                 {
6485                                   if (((word >> 21) & 0x1) == 0)
6486                                     {
6487                                       if (((word >> 30) & 0x1) == 0)
6488                                         {
6489                                           if (((word >> 31) & 0x1) == 0)
6490                                             {
6491                                               if (((word >> 17) & 0x1) == 0)
6492                                                 {
6493                                                   if (((word >> 19) & 0x1) == 0)
6494                                                     {
6495                                                       if (((word >> 20) & 0x1) == 0)
6496                                                         {
6497                                                           if (((word >> 16) & 0x1) == 0)
6498                                                             {
6499                                                               /* 33222222222211111111110000000000
6500                                                                  10987654321098765432109876543210
6501                                                                  000001x0xx000x00001xxxxxxxxxxxxx
6502                                                                  saddv.  */
6503                                                               return 1822;
6504                                                             }
6505                                                           else
6506                                                             {
6507                                                               /* 33222222222211111111110000000000
6508                                                                  10987654321098765432109876543210
6509                                                                  000001x0xx000x01001xxxxxxxxxxxxx
6510                                                                  uaddv.  */
6511                                                               return 1974;
6512                                                             }
6513                                                         }
6514                                                       else
6515                                                         {
6516                                                           /* 33222222222211111111110000000000
6517                                                              10987654321098765432109876543210
6518                                                              000001x0xx010x0x001xxxxxxxxxxxxx
6519                                                              movprfx.  */
6520                                                           return 1757;
6521                                                         }
6522                                                     }
6523                                                   else
6524                                                     {
6525                                                       if (((word >> 16) & 0x1) == 0)
6526                                                         {
6527                                                           if (((word >> 20) & 0x1) == 0)
6528                                                             {
6529                                                               /* 33222222222211111111110000000000
6530                                                                  10987654321098765432109876543210
6531                                                                  000001x0xx001x00001xxxxxxxxxxxxx
6532                                                                  smaxv.  */
6533                                                               return 1840;
6534                                                             }
6535                                                           else
6536                                                             {
6537                                                               /* 33222222222211111111110000000000
6538                                                                  10987654321098765432109876543210
6539                                                                  000001x0xx011x00001xxxxxxxxxxxxx
6540                                                                  orv.  */
6541                                                               return 1774;
6542                                                             }
6543                                                         }
6544                                                       else
6545                                                         {
6546                                                           if (((word >> 20) & 0x1) == 0)
6547                                                             {
6548                                                               /* 33222222222211111111110000000000
6549                                                                  10987654321098765432109876543210
6550                                                                  000001x0xx001x01001xxxxxxxxxxxxx
6551                                                                  umaxv.  */
6552                                                               return 1989;
6553                                                             }
6554                                                           else
6555                                                             {
6556                                                               /* 33222222222211111111110000000000
6557                                                                  10987654321098765432109876543210
6558                                                                  000001x0xx011x01001xxxxxxxxxxxxx
6559                                                                  eorv.  */
6560                                                               return 1389;
6561                                                             }
6562                                                         }
6563                                                     }
6564                                                 }
6565                                               else
6566                                                 {
6567                                                   if (((word >> 16) & 0x1) == 0)
6568                                                     {
6569                                                       if (((word >> 20) & 0x1) == 0)
6570                                                         {
6571                                                           /* 33222222222211111111110000000000
6572                                                              10987654321098765432109876543210
6573                                                              000001x0xx00xx10001xxxxxxxxxxxxx
6574                                                              sminv.  */
6575                                                           return 1843;
6576                                                         }
6577                                                       else
6578                                                         {
6579                                                           /* 33222222222211111111110000000000
6580                                                              10987654321098765432109876543210
6581                                                              000001x0xx01xx10001xxxxxxxxxxxxx
6582                                                              andv.  */
6583                                                           return 1302;
6584                                                         }
6585                                                     }
6586                                                   else
6587                                                     {
6588                                                       /* 33222222222211111111110000000000
6589                                                          10987654321098765432109876543210
6590                                                          000001x0xx0xxx11001xxxxxxxxxxxxx
6591                                                          uminv.  */
6592                                                       return 1992;
6593                                                     }
6594                                                 }
6595                                             }
6596                                           else
6597                                             {
6598                                               if (((word >> 23) & 0x1) == 0)
6599                                                 {
6600                                                   /* 33222222222211111111110000000000
6601                                                      10987654321098765432109876543210
6602                                                      100001x00x0xxxxx001xxxxxxxxxxxxx
6603                                                      ldff1sb.  */
6604                                                   return 1673;
6605                                                 }
6606                                               else
6607                                                 {
6608                                                   /* 33222222222211111111110000000000
6609                                                      10987654321098765432109876543210
6610                                                      100001x01x0xxxxx001xxxxxxxxxxxxx
6611                                                      ldff1sh.  */
6612                                                   return 1684;
6613                                                 }
6614                                             }
6615                                         }
6616                                       else
6617                                         {
6618                                           if (((word >> 31) & 0x1) == 0)
6619                                             {
6620                                               if (((word >> 12) & 0x1) == 0)
6621                                                 {
6622                                                   /* 33222222222211111111110000000000
6623                                                      10987654321098765432109876543210
6624                                                      010001x0xx0xxxxx0010xxxxxxxxxxxx
6625                                                      cmla.  */
6626                                                   return 2074;
6627                                                 }
6628                                               else
6629                                                 {
6630                                                   /* 33222222222211111111110000000000
6631                                                      10987654321098765432109876543210
6632                                                      010001x0xx0xxxxx0011xxxxxxxxxxxx
6633                                                      sqrdcmlah.  */
6634                                                   return 2206;
6635                                                 }
6636                                             }
6637                                           else
6638                                             {
6639                                               if (((word >> 23) & 0x1) == 0)
6640                                                 {
6641                                                   /* 33222222222211111111110000000000
6642                                                      10987654321098765432109876543210
6643                                                      110001x00x0xxxxx001xxxxxxxxxxxxx
6644                                                      ldff1sb.  */
6645                                                   return 1680;
6646                                                 }
6647                                               else
6648                                                 {
6649                                                   /* 33222222222211111111110000000000
6650                                                      10987654321098765432109876543210
6651                                                      110001x01x0xxxxx001xxxxxxxxxxxxx
6652                                                      ldff1sh.  */
6653                                                   return 1690;
6654                                                 }
6655                                             }
6656                                         }
6657                                     }
6658                                   else
6659                                     {
6660                                       if (((word >> 30) & 0x1) == 0)
6661                                         {
6662                                           if (((word >> 31) & 0x1) == 0)
6663                                             {
6664                                               if (((word >> 10) & 0x1) == 0)
6665                                                 {
6666                                                   if (((word >> 11) & 0x1) == 0)
6667                                                     {
6668                                                       if (((word >> 22) & 0x1) == 0)
6669                                                         {
6670                                                           if (((word >> 23) & 0x1) == 0)
6671                                                             {
6672                                                               /* 33222222222211111111110000000000
6673                                                                  10987654321098765432109876543210
6674                                                                  000001x0001xxxxx001x00xxxxxxxxxx
6675                                                                  and.  */
6676                                                               return 1297;
6677                                                             }
6678                                                           else
6679                                                             {
6680                                                               /* 33222222222211111111110000000000
6681                                                                  10987654321098765432109876543210
6682                                                                  000001x0101xxxxx001x00xxxxxxxxxx
6683                                                                  eor.  */
6684                                                               return 1384;
6685                                                             }
6686                                                         }
6687                                                       else
6688                                                         {
6689                                                           if (((word >> 23) & 0x1) == 0)
6690                                                             {
6691                                                               /* 33222222222211111111110000000000
6692                                                                  10987654321098765432109876543210
6693                                                                  000001x0011xxxxx001x00xxxxxxxxxx
6694                                                                  orr.  */
6695                                                               return 1769;
6696                                                             }
6697                                                           else
6698                                                             {
6699                                                               /* 33222222222211111111110000000000
6700                                                                  10987654321098765432109876543210
6701                                                                  000001x0111xxxxx001x00xxxxxxxxxx
6702                                                                  bic.  */
6703                                                               return 1310;
6704                                                             }
6705                                                         }
6706                                                     }
6707                                                   else
6708                                                     {
6709                                                       if (((word >> 22) & 0x1) == 0)
6710                                                         {
6711                                                           /* 33222222222211111111110000000000
6712                                                              10987654321098765432109876543210
6713                                                              000001x0x01xxxxx001x10xxxxxxxxxx
6714                                                              eor3.  */
6715                                                           return 2077;
6716                                                         }
6717                                                       else
6718                                                         {
6719                                                           /* 33222222222211111111110000000000
6720                                                              10987654321098765432109876543210
6721                                                              000001x0x11xxxxx001x10xxxxxxxxxx
6722                                                              bcax.  */
6723                                                           return 2066;
6724                                                         }
6725                                                     }
6726                                                 }
6727                                               else
6728                                                 {
6729                                                   if (((word >> 11) & 0x1) == 0)
6730                                                     {
6731                                                       /* 33222222222211111111110000000000
6732                                                          10987654321098765432109876543210
6733                                                          000001x0xx1xxxxx001x01xxxxxxxxxx
6734                                                          xar.  */
6735                                                       return 2339;
6736                                                     }
6737                                                   else
6738                                                     {
6739                                                       if (((word >> 22) & 0x1) == 0)
6740                                                         {
6741                                                           if (((word >> 23) & 0x1) == 0)
6742                                                             {
6743                                                               /* 33222222222211111111110000000000
6744                                                                  10987654321098765432109876543210
6745                                                                  000001x0001xxxxx001x11xxxxxxxxxx
6746                                                                  bsl.  */
6747                                                               return 2067;
6748                                                             }
6749                                                           else
6750                                                             {
6751                                                               /* 33222222222211111111110000000000
6752                                                                  10987654321098765432109876543210
6753                                                                  000001x0101xxxxx001x11xxxxxxxxxx
6754                                                                  bsl2n.  */
6755                                                               return 2069;
6756                                                             }
6757                                                         }
6758                                                       else
6759                                                         {
6760                                                           if (((word >> 23) & 0x1) == 0)
6761                                                             {
6762                                                               /* 33222222222211111111110000000000
6763                                                                  10987654321098765432109876543210
6764                                                                  000001x0011xxxxx001x11xxxxxxxxxx
6765                                                                  bsl1n.  */
6766                                                               return 2068;
6767                                                             }
6768                                                           else
6769                                                             {
6770                                                               /* 33222222222211111111110000000000
6771                                                                  10987654321098765432109876543210
6772                                                                  000001x0111xxxxx001x11xxxxxxxxxx
6773                                                                  nbsl.  */
6774                                                               return 2124;
6775                                                             }
6776                                                         }
6777                                                     }
6778                                                 }
6779                                             }
6780                                           else
6781                                             {
6782                                               if (((word >> 23) & 0x1) == 0)
6783                                                 {
6784                                                   /* 33222222222211111111110000000000
6785                                                      10987654321098765432109876543210
6786                                                      100001x00x1xxxxx001xxxxxxxxxxxxx
6787                                                      prfh.  */
6788                                                   return 1792;
6789                                                 }
6790                                               else
6791                                                 {
6792                                                   /* 33222222222211111111110000000000
6793                                                      10987654321098765432109876543210
6794                                                      100001x01x1xxxxx001xxxxxxxxxxxxx
6795                                                      ldff1sh.  */
6796                                                   return 1685;
6797                                                 }
6798                                             }
6799                                         }
6800                                       else
6801                                         {
6802                                           if (((word >> 23) & 0x1) == 0)
6803                                             {
6804                                               /* 33222222222211111111110000000000
6805                                                  10987654321098765432109876543210
6806                                                  x10001x00x1xxxxx001xxxxxxxxxxxxx
6807                                                  prfh.  */
6808                                               return 1794;
6809                                             }
6810                                           else
6811                                             {
6812                                               if (((word >> 31) & 0x1) == 0)
6813                                                 {
6814                                                   if (((word >> 10) & 0x1) == 0)
6815                                                     {
6816                                                       if (((word >> 12) & 0x1) == 0)
6817                                                         {
6818                                                           if (((word >> 22) & 0x1) == 0)
6819                                                             {
6820                                                               /* 33222222222211111111110000000000
6821                                                                  10987654321098765432109876543210
6822                                                                  010001x0101xxxxx0010x0xxxxxxxxxx
6823                                                                  sqdmlalb.  */
6824                                                               return 2179;
6825                                                             }
6826                                                           else
6827                                                             {
6828                                                               /* 33222222222211111111110000000000
6829                                                                  10987654321098765432109876543210
6830                                                                  010001x0111xxxxx0010x0xxxxxxxxxx
6831                                                                  sqdmlalb.  */
6832                                                               return 2180;
6833                                                             }
6834                                                         }
6835                                                       else
6836                                                         {
6837                                                           if (((word >> 22) & 0x1) == 0)
6838                                                             {
6839                                                               /* 33222222222211111111110000000000
6840                                                                  10987654321098765432109876543210
6841                                                                  010001x0101xxxxx0011x0xxxxxxxxxx
6842                                                                  sqdmlslb.  */
6843                                                               return 2186;
6844                                                             }
6845                                                           else
6846                                                             {
6847                                                               /* 33222222222211111111110000000000
6848                                                                  10987654321098765432109876543210
6849                                                                  010001x0111xxxxx0011x0xxxxxxxxxx
6850                                                                  sqdmlslb.  */
6851                                                               return 2187;
6852                                                             }
6853                                                         }
6854                                                     }
6855                                                   else
6856                                                     {
6857                                                       if (((word >> 12) & 0x1) == 0)
6858                                                         {
6859                                                           if (((word >> 22) & 0x1) == 0)
6860                                                             {
6861                                                               /* 33222222222211111111110000000000
6862                                                                  10987654321098765432109876543210
6863                                                                  010001x0101xxxxx0010x1xxxxxxxxxx
6864                                                                  sqdmlalt.  */
6865                                                               return 2183;
6866                                                             }
6867                                                           else
6868                                                             {
6869                                                               /* 33222222222211111111110000000000
6870                                                                  10987654321098765432109876543210
6871                                                                  010001x0111xxxxx0010x1xxxxxxxxxx
6872                                                                  sqdmlalt.  */
6873                                                               return 2184;
6874                                                             }
6875                                                         }
6876                                                       else
6877                                                         {
6878                                                           if (((word >> 22) & 0x1) == 0)
6879                                                             {
6880                                                               /* 33222222222211111111110000000000
6881                                                                  10987654321098765432109876543210
6882                                                                  010001x0101xxxxx0011x1xxxxxxxxxx
6883                                                                  sqdmlslt.  */
6884                                                               return 2190;
6885                                                             }
6886                                                           else
6887                                                             {
6888                                                               /* 33222222222211111111110000000000
6889                                                                  10987654321098765432109876543210
6890                                                                  010001x0111xxxxx0011x1xxxxxxxxxx
6891                                                                  sqdmlslt.  */
6892                                                               return 2191;
6893                                                             }
6894                                                         }
6895                                                     }
6896                                                 }
6897                                               else
6898                                                 {
6899                                                   /* 33222222222211111111110000000000
6900                                                      10987654321098765432109876543210
6901                                                      110001x01x1xxxxx001xxxxxxxxxxxxx
6902                                                      ldff1sh.  */
6903                                                   return 1691;
6904                                                 }
6905                                             }
6906                                         }
6907                                     }
6908                                 }
6909                               else
6910                                 {
6911                                   if (((word >> 30) & 0x1) == 0)
6912                                     {
6913                                       if (((word >> 31) & 0x1) == 0)
6914                                         {
6915                                           if (((word >> 21) & 0x1) == 0)
6916                                             {
6917                                               if (((word >> 16) & 0x1) == 0)
6918                                                 {
6919                                                   if (((word >> 17) & 0x1) == 0)
6920                                                     {
6921                                                       if (((word >> 18) & 0x1) == 0)
6922                                                         {
6923                                                           if (((word >> 19) & 0x1) == 0)
6924                                                             {
6925                                                               /* 33222222222211111111110000000000
6926                                                                  10987654321098765432109876543210
6927                                                                  000001x0xx0x0000101xxxxxxxxxxxxx
6928                                                                  sxtb.  */
6929                                                               return 1965;
6930                                                             }
6931                                                           else
6932                                                             {
6933                                                               /* 33222222222211111111110000000000
6934                                                                  10987654321098765432109876543210
6935                                                                  000001x0xx0x1000101xxxxxxxxxxxxx
6936                                                                  cls.  */
6937                                                               return 1330;
6938                                                             }
6939                                                         }
6940                                                       else
6941                                                         {
6942                                                           if (((word >> 19) & 0x1) == 0)
6943                                                             {
6944                                                               /* 33222222222211111111110000000000
6945                                                                  10987654321098765432109876543210
6946                                                                  000001x0xx0x0100101xxxxxxxxxxxxx
6947                                                                  sxtw.  */
6948                                                               return 1967;
6949                                                             }
6950                                                           else
6951                                                             {
6952                                                               /* 33222222222211111111110000000000
6953                                                                  10987654321098765432109876543210
6954                                                                  000001x0xx0x1100101xxxxxxxxxxxxx
6955                                                                  fabs.  */
6956                                                               return 1392;
6957                                                             }
6958                                                         }
6959                                                     }
6960                                                   else
6961                                                     {
6962                                                       if (((word >> 18) & 0x1) == 0)
6963                                                         {
6964                                                           if (((word >> 19) & 0x1) == 0)
6965                                                             {
6966                                                               /* 33222222222211111111110000000000
6967                                                                  10987654321098765432109876543210
6968                                                                  000001x0xx0x0010101xxxxxxxxxxxxx
6969                                                                  sxth.  */
6970                                                               return 1966;
6971                                                             }
6972                                                           else
6973                                                             {
6974                                                               /* 33222222222211111111110000000000
6975                                                                  10987654321098765432109876543210
6976                                                                  000001x0xx0x1010101xxxxxxxxxxxxx
6977                                                                  cnt.  */
6978                                                               return 1359;
6979                                                             }
6980                                                         }
6981                                                       else
6982                                                         {
6983                                                           if (((word >> 19) & 0x1) == 0)
6984                                                             {
6985                                                               /* 33222222222211111111110000000000
6986                                                                  10987654321098765432109876543210
6987                                                                  000001x0xx0x0110101xxxxxxxxxxxxx
6988                                                                  abs.  */
6989                                                               return 1288;
6990                                                             }
6991                                                           else
6992                                                             {
6993                                                               /* 33222222222211111111110000000000
6994                                                                  10987654321098765432109876543210
6995                                                                  000001x0xx0x1110101xxxxxxxxxxxxx
6996                                                                  not.  */
6997                                                               return 1766;
6998                                                             }
6999                                                         }
7000                                                     }
7001                                                 }
7002                                               else
7003                                                 {
7004                                                   if (((word >> 17) & 0x1) == 0)
7005                                                     {
7006                                                       if (((word >> 18) & 0x1) == 0)
7007                                                         {
7008                                                           if (((word >> 19) & 0x1) == 0)
7009                                                             {
7010                                                               /* 33222222222211111111110000000000
7011                                                                  10987654321098765432109876543210
7012                                                                  000001x0xx0x0001101xxxxxxxxxxxxx
7013                                                                  uxtb.  */
7014                                                               return 2028;
7015                                                             }
7016                                                           else
7017                                                             {
7018                                                               /* 33222222222211111111110000000000
7019                                                                  10987654321098765432109876543210
7020                                                                  000001x0xx0x1001101xxxxxxxxxxxxx
7021                                                                  clz.  */
7022                                                               return 1331;
7023                                                             }
7024                                                         }
7025                                                       else
7026                                                         {
7027                                                           if (((word >> 19) & 0x1) == 0)
7028                                                             {
7029                                                               /* 33222222222211111111110000000000
7030                                                                  10987654321098765432109876543210
7031                                                                  000001x0xx0x0101101xxxxxxxxxxxxx
7032                                                                  uxtw.  */
7033                                                               return 2030;
7034                                                             }
7035                                                           else
7036                                                             {
7037                                                               /* 33222222222211111111110000000000
7038                                                                  10987654321098765432109876543210
7039                                                                  000001x0xx0x1101101xxxxxxxxxxxxx
7040                                                                  fneg.  */
7041                                                               return 1469;
7042                                                             }
7043                                                         }
7044                                                     }
7045                                                   else
7046                                                     {
7047                                                       if (((word >> 18) & 0x1) == 0)
7048                                                         {
7049                                                           if (((word >> 19) & 0x1) == 0)
7050                                                             {
7051                                                               /* 33222222222211111111110000000000
7052                                                                  10987654321098765432109876543210
7053                                                                  000001x0xx0x0011101xxxxxxxxxxxxx
7054                                                                  uxth.  */
7055                                                               return 2029;
7056                                                             }
7057                                                           else
7058                                                             {
7059                                                               /* 33222222222211111111110000000000
7060                                                                  10987654321098765432109876543210
7061                                                                  000001x0xx0x1011101xxxxxxxxxxxxx
7062                                                                  cnot.  */
7063                                                               return 1358;
7064                                                             }
7065                                                         }
7066                                                       else
7067                                                         {
7068                                                           /* 33222222222211111111110000000000
7069                                                              10987654321098765432109876543210
7070                                                              000001x0xx0xx111101xxxxxxxxxxxxx
7071                                                              neg.  */
7072                                                           return 1763;
7073                                                         }
7074                                                     }
7075                                                 }
7076                                             }
7077                                           else
7078                                             {
7079                                               if (((word >> 12) & 0x1) == 0)
7080                                                 {
7081                                                   if (((word >> 23) & 0x1) == 0)
7082                                                     {
7083                                                       if (((word >> 22) & 0x1) == 0)
7084                                                         {
7085                                                           /* 33222222222211111111110000000000
7086                                                              10987654321098765432109876543210
7087                                                              000001x0001xxxxx1010xxxxxxxxxxxx
7088                                                              adr.  */
7089                                                           return 1294;
7090                                                         }
7091                                                       else
7092                                                         {
7093                                                           /* 33222222222211111111110000000000
7094                                                              10987654321098765432109876543210
7095                                                              000001x0011xxxxx1010xxxxxxxxxxxx
7096                                                              adr.  */
7097                                                           return 1295;
7098                                                         }
7099                                                     }
7100                                                   else
7101                                                     {
7102                                                       /* 33222222222211111111110000000000
7103                                                          10987654321098765432109876543210
7104                                                          000001x01x1xxxxx1010xxxxxxxxxxxx
7105                                                          adr.  */
7106                                                       return 1296;
7107                                                     }
7108                                                 }
7109                                               else
7110                                                 {
7111                                                   if (((word >> 10) & 0x1) == 0)
7112                                                     {
7113                                                       if (((word >> 11) & 0x1) == 0)
7114                                                         {
7115                                                           /* 33222222222211111111110000000000
7116                                                              10987654321098765432109876543210
7117                                                              000001x0xx1xxxxx101100xxxxxxxxxx
7118                                                              ftssel.  */
7119                                                           return 1495;
7120                                                         }
7121                                                       else
7122                                                         {
7123                                                           /* 33222222222211111111110000000000
7124                                                              10987654321098765432109876543210
7125                                                              000001x0xx1xxxxx101110xxxxxxxxxx
7126                                                              fexpa.  */
7127                                                           return 1439;
7128                                                         }
7129                                                     }
7130                                                   else
7131                                                     {
7132                                                       /* 33222222222211111111110000000000
7133                                                          10987654321098765432109876543210
7134                                                          000001x0xx1xxxxx1011x1xxxxxxxxxx
7135                                                          movprfx.  */
7136                                                       return 1756;
7137                                                     }
7138                                                 }
7139                                             }
7140                                         }
7141                                       else
7142                                         {
7143                                           if (((word >> 22) & 0x1) == 0)
7144                                             {
7145                                               if (((word >> 21) & 0x1) == 0)
7146                                                 {
7147                                                   if (((word >> 23) & 0x1) == 0)
7148                                                     {
7149                                                       /* 33222222222211111111110000000000
7150                                                          10987654321098765432109876543210
7151                                                          100001x0000xxxxx101xxxxxxxxxxxxx
7152                                                          ldnt1b.  */
7153                                                       return 2103;
7154                                                     }
7155                                                   else
7156                                                     {
7157                                                       /* 33222222222211111111110000000000
7158                                                          10987654321098765432109876543210
7159                                                          100001x0100xxxxx101xxxxxxxxxxxxx
7160                                                          ldnt1h.  */
7161                                                       return 2106;
7162                                                     }
7163                                                 }
7164                                               else
7165                                                 {
7166                                                   if (((word >> 23) & 0x1) == 0)
7167                                                     {
7168                                                       /* 33222222222211111111110000000000
7169                                                          10987654321098765432109876543210
7170                                                          100001x0001xxxxx101xxxxxxxxxxxxx
7171                                                          ldff1sb.  */
7172                                                       return 1682;
7173                                                     }
7174                                                   else
7175                                                     {
7176                                                       /* 33222222222211111111110000000000
7177                                                          10987654321098765432109876543210
7178                                                          100001x0101xxxxx101xxxxxxxxxxxxx
7179                                                          ldff1sh.  */
7180                                                       return 1694;
7181                                                     }
7182                                                 }
7183                                             }
7184                                           else
7185                                             {
7186                                               if (((word >> 23) & 0x1) == 0)
7187                                                 {
7188                                                   /* 33222222222211111111110000000000
7189                                                      10987654321098765432109876543210
7190                                                      100001x001xxxxxx101xxxxxxxxxxxxx
7191                                                      ld1rb.  */
7192                                                   return 1550;
7193                                                 }
7194                                               else
7195                                                 {
7196                                                   /* 33222222222211111111110000000000
7197                                                      10987654321098765432109876543210
7198                                                      100001x011xxxxxx101xxxxxxxxxxxxx
7199                                                      ld1rh.  */
7200                                                   return 1554;
7201                                                 }
7202                                             }
7203                                         }
7204                                     }
7205                                   else
7206                                     {
7207                                       if (((word >> 21) & 0x1) == 0)
7208                                         {
7209                                           if (((word >> 31) & 0x1) == 0)
7210                                             {
7211                                               if (((word >> 16) & 0x1) == 0)
7212                                                 {
7213                                                   if (((word >> 17) & 0x1) == 0)
7214                                                     {
7215                                                       if (((word >> 18) & 0x1) == 0)
7216                                                         {
7217                                                           if (((word >> 19) & 0x1) == 0)
7218                                                             {
7219                                                               /* 33222222222211111111110000000000
7220                                                                  10987654321098765432109876543210
7221                                                                  010001x0xx0x0000101xxxxxxxxxxxxx
7222                                                                  urecpe.  */
7223                                                               return 2314;
7224                                                             }
7225                                                           else
7226                                                             {
7227                                                               /* 33222222222211111111110000000000
7228                                                                  10987654321098765432109876543210
7229                                                                  010001x0xx0x1000101xxxxxxxxxxxxx
7230                                                                  sqabs.  */
7231                                                               return 2176;
7232                                                             }
7233                                                         }
7234                                                       else
7235                                                         {
7236                                                           if (((word >> 20) & 0x1) == 0)
7237                                                             {
7238                                                               /* 33222222222211111111110000000000
7239                                                                  10987654321098765432109876543210
7240                                                                  010001x0xx00x100101xxxxxxxxxxxxx
7241                                                                  sadalp.  */
7242                                                               return 2140;
7243                                                             }
7244                                                           else
7245                                                             {
7246                                                               /* 33222222222211111111110000000000
7247                                                                  10987654321098765432109876543210
7248                                                                  010001x0xx01x100101xxxxxxxxxxxxx
7249                                                                  smaxp.  */
7250                                                               return 2154;
7251                                                             }
7252                                                         }
7253                                                     }
7254                                                   else
7255                                                     {
7256                                                       /* 33222222222211111111110000000000
7257                                                          10987654321098765432109876543210
7258                                                          010001x0xx0xxx10101xxxxxxxxxxxxx
7259                                                          sminp.  */
7260                                                       return 2155;
7261                                                     }
7262                                                 }
7263                                               else
7264                                                 {
7265                                                   if (((word >> 17) & 0x1) == 0)
7266                                                     {
7267                                                       if (((word >> 18) & 0x1) == 0)
7268                                                         {
7269                                                           if (((word >> 19) & 0x1) == 0)
7270                                                             {
7271                                                               if (((word >> 20) & 0x1) == 0)
7272                                                                 {
7273                                                                   /* 33222222222211111111110000000000
7274                                                                      10987654321098765432109876543210
7275                                                                      010001x0xx000001101xxxxxxxxxxxxx
7276                                                                      ursqrte.  */
7277                                                                   return 2319;
7278                                                                 }
7279                                                               else
7280                                                                 {
7281                                                                   /* 33222222222211111111110000000000
7282                                                                      10987654321098765432109876543210
7283                                                                      010001x0xx010001101xxxxxxxxxxxxx
7284                                                                      addp.  */
7285                                                                   return 2065;
7286                                                                 }
7287                                                             }
7288                                                           else
7289                                                             {
7290                                                               /* 33222222222211111111110000000000
7291                                                                  10987654321098765432109876543210
7292                                                                  010001x0xx0x1001101xxxxxxxxxxxxx
7293                                                                  sqneg.  */
7294                                                               return 2203;
7295                                                             }
7296                                                         }
7297                                                       else
7298                                                         {
7299                                                           if (((word >> 20) & 0x1) == 0)
7300                                                             {
7301                                                               /* 33222222222211111111110000000000
7302                                                                  10987654321098765432109876543210
7303                                                                  010001x0xx00x101101xxxxxxxxxxxxx
7304                                                                  uadalp.  */
7305                                                               return 2271;
7306                                                             }
7307                                                           else
7308                                                             {
7309                                                               /* 33222222222211111111110000000000
7310                                                                  10987654321098765432109876543210
7311                                                                  010001x0xx01x101101xxxxxxxxxxxxx
7312                                                                  umaxp.  */
7313                                                               return 2279;
7314                                                             }
7315                                                         }
7316                                                     }
7317                                                   else
7318                                                     {
7319                                                       /* 33222222222211111111110000000000
7320                                                          10987654321098765432109876543210
7321                                                          010001x0xx0xxx11101xxxxxxxxxxxxx
7322                                                          uminp.  */
7323                                                       return 2280;
7324                                                     }
7325                                                 }
7326                                             }
7327                                           else
7328                                             {
7329                                               if (((word >> 23) & 0x1) == 0)
7330                                                 {
7331                                                   /* 33222222222211111111110000000000
7332                                                      10987654321098765432109876543210
7333                                                      110001x00x0xxxxx101xxxxxxxxxxxxx
7334                                                      ldff1sb.  */
7335                                                   return 1681;
7336                                                 }
7337                                               else
7338                                                 {
7339                                                   /* 33222222222211111111110000000000
7340                                                      10987654321098765432109876543210
7341                                                      110001x01x0xxxxx101xxxxxxxxxxxxx
7342                                                      ldff1sh.  */
7343                                                   return 1692;
7344                                                 }
7345                                             }
7346                                         }
7347                                       else
7348                                         {
7349                                           if (((word >> 22) & 0x1) == 0)
7350                                             {
7351                                               if (((word >> 23) & 0x1) == 0)
7352                                                 {
7353                                                   /* 33222222222211111111110000000000
7354                                                      10987654321098765432109876543210
7355                                                      x10001x0001xxxxx101xxxxxxxxxxxxx
7356                                                      ldff1sb.  */
7357                                                   return 1683;
7358                                                 }
7359                                               else
7360                                                 {
7361                                                   if (((word >> 31) & 0x1) == 0)
7362                                                     {
7363                                                       if (((word >> 10) & 0x1) == 0)
7364                                                         {
7365                                                           if (((word >> 12) & 0x1) == 0)
7366                                                             {
7367                                                               /* 33222222222211111111110000000000
7368                                                                  10987654321098765432109876543210
7369                                                                  010001x0101xxxxx1010x0xxxxxxxxxx
7370                                                                  smlslb.  */
7371                                                               return 2162;
7372                                                             }
7373                                                           else
7374                                                             {
7375                                                               /* 33222222222211111111110000000000
7376                                                                  10987654321098765432109876543210
7377                                                                  010001x0101xxxxx1011x0xxxxxxxxxx
7378                                                                  umlslb.  */
7379                                                               return 2287;
7380                                                             }
7381                                                         }
7382                                                       else
7383                                                         {
7384                                                           if (((word >> 12) & 0x1) == 0)
7385                                                             {
7386                                                               /* 33222222222211111111110000000000
7387                                                                  10987654321098765432109876543210
7388                                                                  010001x0101xxxxx1010x1xxxxxxxxxx
7389                                                                  smlslt.  */
7390                                                               return 2165;
7391                                                             }
7392                                                           else
7393                                                             {
7394                                                               /* 33222222222211111111110000000000
7395                                                                  10987654321098765432109876543210
7396                                                                  010001x0101xxxxx1011x1xxxxxxxxxx
7397                                                                  umlslt.  */
7398                                                               return 2290;
7399                                                             }
7400                                                         }
7401                                                     }
7402                                                   else
7403                                                     {
7404                                                       /* 33222222222211111111110000000000
7405                                                          10987654321098765432109876543210
7406                                                          110001x0101xxxxx101xxxxxxxxxxxxx
7407                                                          ldff1sh.  */
7408                                                       return 1695;
7409                                                     }
7410                                                 }
7411                                             }
7412                                           else
7413                                             {
7414                                               if (((word >> 23) & 0x1) == 0)
7415                                                 {
7416                                                   /* 33222222222211111111110000000000
7417                                                      10987654321098765432109876543210
7418                                                      x10001x0011xxxxx101xxxxxxxxxxxxx
7419                                                      prfh.  */
7420                                                   return 1795;
7421                                                 }
7422                                               else
7423                                                 {
7424                                                   if (((word >> 31) & 0x1) == 0)
7425                                                     {
7426                                                       if (((word >> 10) & 0x1) == 0)
7427                                                         {
7428                                                           if (((word >> 12) & 0x1) == 0)
7429                                                             {
7430                                                               /* 33222222222211111111110000000000
7431                                                                  10987654321098765432109876543210
7432                                                                  010001x0111xxxxx1010x0xxxxxxxxxx
7433                                                                  smlslb.  */
7434                                                               return 2163;
7435                                                             }
7436                                                           else
7437                                                             {
7438                                                               /* 33222222222211111111110000000000
7439                                                                  10987654321098765432109876543210
7440                                                                  010001x0111xxxxx1011x0xxxxxxxxxx
7441                                                                  umlslb.  */
7442                                                               return 2288;
7443                                                             }
7444                                                         }
7445                                                       else
7446                                                         {
7447                                                           if (((word >> 12) & 0x1) == 0)
7448                                                             {
7449                                                               /* 33222222222211111111110000000000
7450                                                                  10987654321098765432109876543210
7451                                                                  010001x0111xxxxx1010x1xxxxxxxxxx
7452                                                                  smlslt.  */
7453                                                               return 2166;
7454                                                             }
7455                                                           else
7456                                                             {
7457                                                               /* 33222222222211111111110000000000
7458                                                                  10987654321098765432109876543210
7459                                                                  010001x0111xxxxx1011x1xxxxxxxxxx
7460                                                                  umlslt.  */
7461                                                               return 2291;
7462                                                             }
7463                                                         }
7464                                                     }
7465                                                   else
7466                                                     {
7467                                                       /* 33222222222211111111110000000000
7468                                                          10987654321098765432109876543210
7469                                                          110001x0111xxxxx101xxxxxxxxxxxxx
7470                                                          ldff1sh.  */
7471                                                       return 1693;
7472                                                     }
7473                                                 }
7474                                             }
7475                                         }
7476                                     }
7477                                 }
7478                             }
7479                           else
7480                             {
7481                               if (((word >> 15) & 0x1) == 0)
7482                                 {
7483                                   if (((word >> 21) & 0x1) == 0)
7484                                     {
7485                                       if (((word >> 30) & 0x1) == 0)
7486                                         {
7487                                           if (((word >> 31) & 0x1) == 0)
7488                                             {
7489                                               /* 33222222222211111111110000000000
7490                                                  10987654321098765432109876543210
7491                                                  000001x0xx0xxxxx011xxxxxxxxxxxxx
7492                                                  mls.  */
7493                                               return 1755;
7494                                             }
7495                                           else
7496                                             {
7497                                               if (((word >> 23) & 0x1) == 0)
7498                                                 {
7499                                                   /* 33222222222211111111110000000000
7500                                                      10987654321098765432109876543210
7501                                                      100001x00x0xxxxx011xxxxxxxxxxxxx
7502                                                      ldff1b.  */
7503                                                   return 1639;
7504                                                 }
7505                                               else
7506                                                 {
7507                                                   /* 33222222222211111111110000000000
7508                                                      10987654321098765432109876543210
7509                                                      100001x01x0xxxxx011xxxxxxxxxxxxx
7510                                                      ldff1h.  */
7511                                                   return 1659;
7512                                                 }
7513                                             }
7514                                         }
7515                                       else
7516                                         {
7517                                           if (((word >> 31) & 0x1) == 0)
7518                                             {
7519                                               if (((word >> 10) & 0x1) == 0)
7520                                                 {
7521                                                   if (((word >> 11) & 0x1) == 0)
7522                                                     {
7523                                                       if (((word >> 12) & 0x1) == 0)
7524                                                         {
7525                                                           /* 33222222222211111111110000000000
7526                                                              10987654321098765432109876543210
7527                                                              010001x0xx0xxxxx011000xxxxxxxxxx
7528                                                              sqdmlalb.  */
7529                                                           return 2181;
7530                                                         }
7531                                                       else
7532                                                         {
7533                                                           /* 33222222222211111111110000000000
7534                                                              10987654321098765432109876543210
7535                                                              010001x0xx0xxxxx011100xxxxxxxxxx
7536                                                              sqrdmlah.  */
7537                                                           return 2210;
7538                                                         }
7539                                                     }
7540                                                   else
7541                                                     {
7542                                                       if (((word >> 12) & 0x1) == 0)
7543                                                         {
7544                                                           /* 33222222222211111111110000000000
7545                                                              10987654321098765432109876543210
7546                                                              010001x0xx0xxxxx011010xxxxxxxxxx
7547                                                              sqdmlslb.  */
7548                                                           return 2188;
7549                                                         }
7550                                                       else
7551                                                         {
7552                                                           /* 33222222222211111111110000000000
7553                                                              10987654321098765432109876543210
7554                                                              010001x0xx0xxxxx011110xxxxxxxxxx
7555                                                              usdot.  */
7556                                                           return 2467;
7557                                                         }
7558                                                     }
7559                                                 }
7560                                               else
7561                                                 {
7562                                                   if (((word >> 11) & 0x1) == 0)
7563                                                     {
7564                                                       if (((word >> 12) & 0x1) == 0)
7565                                                         {
7566                                                           /* 33222222222211111111110000000000
7567                                                              10987654321098765432109876543210
7568                                                              010001x0xx0xxxxx011001xxxxxxxxxx
7569                                                              sqdmlalt.  */
7570                                                           return 2185;
7571                                                         }
7572                                                       else
7573                                                         {
7574                                                           /* 33222222222211111111110000000000
7575                                                              10987654321098765432109876543210
7576                                                              010001x0xx0xxxxx011101xxxxxxxxxx
7577                                                              sqrdmlsh.  */
7578                                                           return 2214;
7579                                                         }
7580                                                     }
7581                                                   else
7582                                                     {
7583                                                       /* 33222222222211111111110000000000
7584                                                          10987654321098765432109876543210
7585                                                          010001x0xx0xxxxx011x11xxxxxxxxxx
7586                                                          sqdmlslt.  */
7587                                                       return 2192;
7588                                                     }
7589                                                 }
7590                                             }
7591                                           else
7592                                             {
7593                                               if (((word >> 23) & 0x1) == 0)
7594                                                 {
7595                                                   /* 33222222222211111111110000000000
7596                                                      10987654321098765432109876543210
7597                                                      110001x00x0xxxxx011xxxxxxxxxxxxx
7598                                                      ldff1b.  */
7599                                                   return 1648;
7600                                                 }
7601                                               else
7602                                                 {
7603                                                   /* 33222222222211111111110000000000
7604                                                      10987654321098765432109876543210
7605                                                      110001x01x0xxxxx011xxxxxxxxxxxxx
7606                                                      ldff1h.  */
7607                                                   return 1667;
7608                                                 }
7609                                             }
7610                                         }
7611                                     }
7612                                   else
7613                                     {
7614                                       if (((word >> 30) & 0x1) == 0)
7615                                         {
7616                                           if (((word >> 31) & 0x1) == 0)
7617                                             {
7618                                               if (((word >> 10) & 0x1) == 0)
7619                                                 {
7620                                                   if (((word >> 11) & 0x1) == 0)
7621                                                     {
7622                                                       if (((word >> 12) & 0x1) == 0)
7623                                                         {
7624                                                           /* 33222222222211111111110000000000
7625                                                              10987654321098765432109876543210
7626                                                              000001x0xx1xxxxx011000xxxxxxxxxx
7627                                                              mul.  */
7628                                                           return 2123;
7629                                                         }
7630                                                       else
7631                                                         {
7632                                                           /* 33222222222211111111110000000000
7633                                                              10987654321098765432109876543210
7634                                                              000001x0xx1xxxxx011100xxxxxxxxxx
7635                                                              sqdmulh.  */
7636                                                           return 2196;
7637                                                         }
7638                                                     }
7639                                                   else
7640                                                     {
7641                                                       /* 33222222222211111111110000000000
7642                                                          10987654321098765432109876543210
7643                                                          000001x0xx1xxxxx011x10xxxxxxxxxx
7644                                                          smulh.  */
7645                                                       return 2168;
7646                                                     }
7647                                                 }
7648                                               else
7649                                                 {
7650                                                   if (((word >> 11) & 0x1) == 0)
7651                                                     {
7652                                                       if (((word >> 12) & 0x1) == 0)
7653                                                         {
7654                                                           /* 33222222222211111111110000000000
7655                                                              10987654321098765432109876543210
7656                                                              000001x0xx1xxxxx011001xxxxxxxxxx
7657                                                              pmul.  */
7658                                                           return 2126;
7659                                                         }
7660                                                       else
7661                                                         {
7662                                                           /* 33222222222211111111110000000000
7663                                                              10987654321098765432109876543210
7664                                                              000001x0xx1xxxxx011101xxxxxxxxxx
7665                                                              sqrdmulh.  */
7666                                                           return 2218;
7667                                                         }
7668                                                     }
7669                                                   else
7670                                                     {
7671                                                       /* 33222222222211111111110000000000
7672                                                          10987654321098765432109876543210
7673                                                          000001x0xx1xxxxx011x11xxxxxxxxxx
7674                                                          umulh.  */
7675                                                       return 2293;
7676                                                     }
7677                                                 }
7678                                             }
7679                                           else
7680                                             {
7681                                               if (((word >> 23) & 0x1) == 0)
7682                                                 {
7683                                                   /* 33222222222211111111110000000000
7684                                                      10987654321098765432109876543210
7685                                                      100001x00x1xxxxx011xxxxxxxxxxxxx
7686                                                      prfd.  */
7687                                                   return 1785;
7688                                                 }
7689                                               else
7690                                                 {
7691                                                   /* 33222222222211111111110000000000
7692                                                      10987654321098765432109876543210
7693                                                      100001x01x1xxxxx011xxxxxxxxxxxxx
7694                                                      ldff1h.  */
7695                                                   return 1660;
7696                                                 }
7697                                             }
7698                                         }
7699                                       else
7700                                         {
7701                                           if (((word >> 23) & 0x1) == 0)
7702                                             {
7703                                               /* 33222222222211111111110000000000
7704                                                  10987654321098765432109876543210
7705                                                  x10001x00x1xxxxx011xxxxxxxxxxxxx
7706                                                  prfd.  */
7707                                               return 1787;
7708                                             }
7709                                           else
7710                                             {
7711                                               if (((word >> 31) & 0x1) == 0)
7712                                                 {
7713                                                   if (((word >> 12) & 0x1) == 0)
7714                                                     {
7715                                                       if (((word >> 22) & 0x1) == 0)
7716                                                         {
7717                                                           /* 33222222222211111111110000000000
7718                                                              10987654321098765432109876543210
7719                                                              010001x0101xxxxx0110xxxxxxxxxxxx
7720                                                              cmla.  */
7721                                                           return 2075;
7722                                                         }
7723                                                       else
7724                                                         {
7725                                                           /* 33222222222211111111110000000000
7726                                                              10987654321098765432109876543210
7727                                                              010001x0111xxxxx0110xxxxxxxxxxxx
7728                                                              cmla.  */
7729                                                           return 2076;
7730                                                         }
7731                                                     }
7732                                                   else
7733                                                     {
7734                                                       if (((word >> 22) & 0x1) == 0)
7735                                                         {
7736                                                           /* 33222222222211111111110000000000
7737                                                              10987654321098765432109876543210
7738                                                              010001x0101xxxxx0111xxxxxxxxxxxx
7739                                                              sqrdcmlah.  */
7740                                                           return 2204;
7741                                                         }
7742                                                       else
7743                                                         {
7744                                                           /* 33222222222211111111110000000000
7745                                                              10987654321098765432109876543210
7746                                                              010001x0111xxxxx0111xxxxxxxxxxxx
7747                                                              sqrdcmlah.  */
7748                                                           return 2205;
7749                                                         }
7750                                                     }
7751                                                 }
7752                                               else
7753                                                 {
7754                                                   /* 33222222222211111111110000000000
7755                                                      10987654321098765432109876543210
7756                                                      110001x01x1xxxxx011xxxxxxxxxxxxx
7757                                                      ldff1h.  */
7758                                                   return 1668;
7759                                                 }
7760                                             }
7761                                         }
7762                                     }
7763                                 }
7764                               else
7765                                 {
7766                                   if (((word >> 30) & 0x1) == 0)
7767                                     {
7768                                       if (((word >> 31) & 0x1) == 0)
7769                                         {
7770                                           if (((word >> 21) & 0x1) == 0)
7771                                             {
7772                                               /* 33222222222211111111110000000000
7773                                                  10987654321098765432109876543210
7774                                                  000001x0xx0xxxxx111xxxxxxxxxxxxx
7775                                                  msb.  */
7776                                               return 1758;
7777                                             }
7778                                           else
7779                                             {
7780                                               if (((word >> 10) & 0x1) == 0)
7781                                                 {
7782                                                   if (((word >> 11) & 0x1) == 0)
7783                                                     {
7784                                                       if (((word >> 12) & 0x1) == 0)
7785                                                         {
7786                                                           if (((word >> 20) & 0x1) == 0)
7787                                                             {
7788                                                               if (((word >> 22) & 0x1) == 0)
7789                                                                 {
7790                                                                   if (((word >> 23) & 0x1) == 0)
7791                                                                     {
7792                                                                       /* 33222222222211111111110000000000
7793                                                                          10987654321098765432109876543210
7794                                                                          000001x00010xxxx111000xxxxxxxxxx
7795                                                                          cntb.  */
7796                                                                       return 1360;
7797                                                                     }
7798                                                                   else
7799                                                                     {
7800                                                                       /* 33222222222211111111110000000000
7801                                                                          10987654321098765432109876543210
7802                                                                          000001x01010xxxx111000xxxxxxxxxx
7803                                                                          cntw.  */
7804                                                                       return 1364;
7805                                                                     }
7806                                                                 }
7807                                                               else
7808                                                                 {
7809                                                                   if (((word >> 23) & 0x1) == 0)
7810                                                                     {
7811                                                                       /* 33222222222211111111110000000000
7812                                                                          10987654321098765432109876543210
7813                                                                          000001x00110xxxx111000xxxxxxxxxx
7814                                                                          cnth.  */
7815                                                                       return 1362;
7816                                                                     }
7817                                                                   else
7818                                                                     {
7819                                                                       /* 33222222222211111111110000000000
7820                                                                          10987654321098765432109876543210
7821                                                                          000001x01110xxxx111000xxxxxxxxxx
7822                                                                          cntd.  */
7823                                                                       return 1361;
7824                                                                     }
7825                                                                 }
7826                                                             }
7827                                                           else
7828                                                             {
7829                                                               if (((word >> 22) & 0x1) == 0)
7830                                                                 {
7831                                                                   if (((word >> 23) & 0x1) == 0)
7832                                                                     {
7833                                                                       /* 33222222222211111111110000000000
7834                                                                          10987654321098765432109876543210
7835                                                                          000001x00011xxxx111000xxxxxxxxxx
7836                                                                          incb.  */
7837                                                                       return 1496;
7838                                                                     }
7839                                                                   else
7840                                                                     {
7841                                                                       /* 33222222222211111111110000000000
7842                                                                          10987654321098765432109876543210
7843                                                                          000001x01011xxxx111000xxxxxxxxxx
7844                                                                          incw.  */
7845                                                                       return 1504;
7846                                                                     }
7847                                                                 }
7848                                                               else
7849                                                                 {
7850                                                                   if (((word >> 23) & 0x1) == 0)
7851                                                                     {
7852                                                                       /* 33222222222211111111110000000000
7853                                                                          10987654321098765432109876543210
7854                                                                          000001x00111xxxx111000xxxxxxxxxx
7855                                                                          inch.  */
7856                                                                       return 1500;
7857                                                                     }
7858                                                                   else
7859                                                                     {
7860                                                                       /* 33222222222211111111110000000000
7861                                                                          10987654321098765432109876543210
7862                                                                          000001x01111xxxx111000xxxxxxxxxx
7863                                                                          incd.  */
7864                                                                       return 1498;
7865                                                                     }
7866                                                                 }
7867                                                             }
7868                                                         }
7869                                                       else
7870                                                         {
7871                                                           if (((word >> 20) & 0x1) == 0)
7872                                                             {
7873                                                               if (((word >> 22) & 0x1) == 0)
7874                                                                 {
7875                                                                   if (((word >> 23) & 0x1) == 0)
7876                                                                     {
7877                                                                       /* 33222222222211111111110000000000
7878                                                                          10987654321098765432109876543210
7879                                                                          000001x00010xxxx111100xxxxxxxxxx
7880                                                                          sqincb.  */
7881                                                                       return 1863;
7882                                                                     }
7883                                                                   else
7884                                                                     {
7885                                                                       /* 33222222222211111111110000000000
7886                                                                          10987654321098765432109876543210
7887                                                                          000001x01010xxxx111100xxxxxxxxxx
7888                                                                          sqincw.  */
7889                                                                       return 1875;
7890                                                                     }
7891                                                                 }
7892                                                               else
7893                                                                 {
7894                                                                   if (((word >> 23) & 0x1) == 0)
7895                                                                     {
7896                                                                       /* 33222222222211111111110000000000
7897                                                                          10987654321098765432109876543210
7898                                                                          000001x00110xxxx111100xxxxxxxxxx
7899                                                                          sqinch.  */
7900                                                                       return 1869;
7901                                                                     }
7902                                                                   else
7903                                                                     {
7904                                                                       /* 33222222222211111111110000000000
7905                                                                          10987654321098765432109876543210
7906                                                                          000001x01110xxxx111100xxxxxxxxxx
7907                                                                          sqincd.  */
7908                                                                       return 1866;
7909                                                                     }
7910                                                                 }
7911                                                             }
7912                                                           else
7913                                                             {
7914                                                               if (((word >> 22) & 0x1) == 0)
7915                                                                 {
7916                                                                   if (((word >> 23) & 0x1) == 0)
7917                                                                     {
7918                                                                       /* 33222222222211111111110000000000
7919                                                                          10987654321098765432109876543210
7920                                                                          000001x00011xxxx111100xxxxxxxxxx
7921                                                                          sqincb.  */
7922                                                                       return 1862;
7923                                                                     }
7924                                                                   else
7925                                                                     {
7926                                                                       /* 33222222222211111111110000000000
7927                                                                          10987654321098765432109876543210
7928                                                                          000001x01011xxxx111100xxxxxxxxxx
7929                                                                          sqincw.  */
7930                                                                       return 1874;
7931                                                                     }
7932                                                                 }
7933                                                               else
7934                                                                 {
7935                                                                   if (((word >> 23) & 0x1) == 0)
7936                                                                     {
7937                                                                       /* 33222222222211111111110000000000
7938                                                                          10987654321098765432109876543210
7939                                                                          000001x00111xxxx111100xxxxxxxxxx
7940                                                                          sqinch.  */
7941                                                                       return 1868;
7942                                                                     }
7943                                                                   else
7944                                                                     {
7945                                                                       /* 33222222222211111111110000000000
7946                                                                          10987654321098765432109876543210
7947                                                                          000001x01111xxxx111100xxxxxxxxxx
7948                                                                          sqincd.  */
7949                                                                       return 1865;
7950                                                                     }
7951                                                                 }
7952                                                             }
7953                                                         }
7954                                                     }
7955                                                   else
7956                                                     {
7957                                                       if (((word >> 20) & 0x1) == 0)
7958                                                         {
7959                                                           if (((word >> 22) & 0x1) == 0)
7960                                                             {
7961                                                               if (((word >> 23) & 0x1) == 0)
7962                                                                 {
7963                                                                   /* 33222222222211111111110000000000
7964                                                                      10987654321098765432109876543210
7965                                                                      000001x00010xxxx111x10xxxxxxxxxx
7966                                                                      sqdecb.  */
7967                                                                   return 1849;
7968                                                                 }
7969                                                               else
7970                                                                 {
7971                                                                   /* 33222222222211111111110000000000
7972                                                                      10987654321098765432109876543210
7973                                                                      000001x01010xxxx111x10xxxxxxxxxx
7974                                                                      sqdecw.  */
7975                                                                   return 1861;
7976                                                                 }
7977                                                             }
7978                                                           else
7979                                                             {
7980                                                               if (((word >> 23) & 0x1) == 0)
7981                                                                 {
7982                                                                   /* 33222222222211111111110000000000
7983                                                                      10987654321098765432109876543210
7984                                                                      000001x00110xxxx111x10xxxxxxxxxx
7985                                                                      sqdech.  */
7986                                                                   return 1855;
7987                                                                 }
7988                                                               else
7989                                                                 {
7990                                                                   /* 33222222222211111111110000000000
7991                                                                      10987654321098765432109876543210
7992                                                                      000001x01110xxxx111x10xxxxxxxxxx
7993                                                                      sqdecd.  */
7994                                                                   return 1852;
7995                                                                 }
7996                                                             }
7997                                                         }
7998                                                       else
7999                                                         {
8000                                                           if (((word >> 22) & 0x1) == 0)
8001                                                             {
8002                                                               if (((word >> 23) & 0x1) == 0)
8003                                                                 {
8004                                                                   /* 33222222222211111111110000000000
8005                                                                      10987654321098765432109876543210
8006                                                                      000001x00011xxxx111x10xxxxxxxxxx
8007                                                                      sqdecb.  */
8008                                                                   return 1848;
8009                                                                 }
8010                                                               else
8011                                                                 {
8012                                                                   /* 33222222222211111111110000000000
8013                                                                      10987654321098765432109876543210
8014                                                                      000001x01011xxxx111x10xxxxxxxxxx
8015                                                                      sqdecw.  */
8016                                                                   return 1860;
8017                                                                 }
8018                                                             }
8019                                                           else
8020                                                             {
8021                                                               if (((word >> 23) & 0x1) == 0)
8022                                                                 {
8023                                                                   /* 33222222222211111111110000000000
8024                                                                      10987654321098765432109876543210
8025                                                                      000001x00111xxxx111x10xxxxxxxxxx
8026                                                                      sqdech.  */
8027                                                                   return 1854;
8028                                                                 }
8029                                                               else
8030                                                                 {
8031                                                                   /* 33222222222211111111110000000000
8032                                                                      10987654321098765432109876543210
8033                                                                      000001x01111xxxx111x10xxxxxxxxxx
8034                                                                      sqdecd.  */
8035                                                                   return 1851;
8036                                                                 }
8037                                                             }
8038                                                         }
8039                                                     }
8040                                                 }
8041                                               else
8042                                                 {
8043                                                   if (((word >> 11) & 0x1) == 0)
8044                                                     {
8045                                                       if (((word >> 12) & 0x1) == 0)
8046                                                         {
8047                                                           if (((word >> 22) & 0x1) == 0)
8048                                                             {
8049                                                               if (((word >> 23) & 0x1) == 0)
8050                                                                 {
8051                                                                   /* 33222222222211111111110000000000
8052                                                                      10987654321098765432109876543210
8053                                                                      000001x0001xxxxx111001xxxxxxxxxx
8054                                                                      decb.  */
8055                                                                   return 1371;
8056                                                                 }
8057                                                               else
8058                                                                 {
8059                                                                   /* 33222222222211111111110000000000
8060                                                                      10987654321098765432109876543210
8061                                                                      000001x0101xxxxx111001xxxxxxxxxx
8062                                                                      decw.  */
8063                                                                   return 1379;
8064                                                                 }
8065                                                             }
8066                                                           else
8067                                                             {
8068                                                               if (((word >> 23) & 0x1) == 0)
8069                                                                 {
8070                                                                   /* 33222222222211111111110000000000
8071                                                                      10987654321098765432109876543210
8072                                                                      000001x0011xxxxx111001xxxxxxxxxx
8073                                                                      dech.  */
8074                                                                   return 1375;
8075                                                                 }
8076                                                               else
8077                                                                 {
8078                                                                   /* 33222222222211111111110000000000
8079                                                                      10987654321098765432109876543210
8080                                                                      000001x0111xxxxx111001xxxxxxxxxx
8081                                                                      decd.  */
8082                                                                   return 1373;
8083                                                                 }
8084                                                             }
8085                                                         }
8086                                                       else
8087                                                         {
8088                                                           if (((word >> 20) & 0x1) == 0)
8089                                                             {
8090                                                               if (((word >> 22) & 0x1) == 0)
8091                                                                 {
8092                                                                   if (((word >> 23) & 0x1) == 0)
8093                                                                     {
8094                                                                       /* 33222222222211111111110000000000
8095                                                                          10987654321098765432109876543210
8096                                                                          000001x00010xxxx111101xxxxxxxxxx
8097                                                                          uqincb.  */
8098                                                                       return 2010;
8099                                                                     }
8100                                                                   else
8101                                                                     {
8102                                                                       /* 33222222222211111111110000000000
8103                                                                          10987654321098765432109876543210
8104                                                                          000001x01010xxxx111101xxxxxxxxxx
8105                                                                          uqincw.  */
8106                                                                       return 2022;
8107                                                                     }
8108                                                                 }
8109                                                               else
8110                                                                 {
8111                                                                   if (((word >> 23) & 0x1) == 0)
8112                                                                     {
8113                                                                       /* 33222222222211111111110000000000
8114                                                                          10987654321098765432109876543210
8115                                                                          000001x00110xxxx111101xxxxxxxxxx
8116                                                                          uqinch.  */
8117                                                                       return 2016;
8118                                                                     }
8119                                                                   else
8120                                                                     {
8121                                                                       /* 33222222222211111111110000000000
8122                                                                          10987654321098765432109876543210
8123                                                                          000001x01110xxxx111101xxxxxxxxxx
8124                                                                          uqincd.  */
8125                                                                       return 2013;
8126                                                                     }
8127                                                                 }
8128                                                             }
8129                                                           else
8130                                                             {
8131                                                               if (((word >> 22) & 0x1) == 0)
8132                                                                 {
8133                                                                   if (((word >> 23) & 0x1) == 0)
8134                                                                     {
8135                                                                       /* 33222222222211111111110000000000
8136                                                                          10987654321098765432109876543210
8137                                                                          000001x00011xxxx111101xxxxxxxxxx
8138                                                                          uqincb.  */
8139                                                                       return 2011;
8140                                                                     }
8141                                                                   else
8142                                                                     {
8143                                                                       /* 33222222222211111111110000000000
8144                                                                          10987654321098765432109876543210
8145                                                                          000001x01011xxxx111101xxxxxxxxxx
8146                                                                          uqincw.  */
8147                                                                       return 2023;
8148                                                                     }
8149                                                                 }
8150                                                               else
8151                                                                 {
8152                                                                   if (((word >> 23) & 0x1) == 0)
8153                                                                     {
8154                                                                       /* 33222222222211111111110000000000
8155                                                                          10987654321098765432109876543210
8156                                                                          000001x00111xxxx111101xxxxxxxxxx
8157                                                                          uqinch.  */
8158                                                                       return 2017;
8159                                                                     }
8160                                                                   else
8161                                                                     {
8162                                                                       /* 33222222222211111111110000000000
8163                                                                          10987654321098765432109876543210
8164                                                                          000001x01111xxxx111101xxxxxxxxxx
8165                                                                          uqincd.  */
8166                                                                       return 2014;
8167                                                                     }
8168                                                                 }
8169                                                             }
8170                                                         }
8171                                                     }
8172                                                   else
8173                                                     {
8174                                                       if (((word >> 20) & 0x1) == 0)
8175                                                         {
8176                                                           if (((word >> 22) & 0x1) == 0)
8177                                                             {
8178                                                               if (((word >> 23) & 0x1) == 0)
8179                                                                 {
8180                                                                   /* 33222222222211111111110000000000
8181                                                                      10987654321098765432109876543210
8182                                                                      000001x00010xxxx111x11xxxxxxxxxx
8183                                                                      uqdecb.  */
8184                                                                   return 1996;
8185                                                                 }
8186                                                               else
8187                                                                 {
8188                                                                   /* 33222222222211111111110000000000
8189                                                                      10987654321098765432109876543210
8190                                                                      000001x01010xxxx111x11xxxxxxxxxx
8191                                                                      uqdecw.  */
8192                                                                   return 2008;
8193                                                                 }
8194                                                             }
8195                                                           else
8196                                                             {
8197                                                               if (((word >> 23) & 0x1) == 0)
8198                                                                 {
8199                                                                   /* 33222222222211111111110000000000
8200                                                                      10987654321098765432109876543210
8201                                                                      000001x00110xxxx111x11xxxxxxxxxx
8202                                                                      uqdech.  */
8203                                                                   return 2002;
8204                                                                 }
8205                                                               else
8206                                                                 {
8207                                                                   /* 33222222222211111111110000000000
8208                                                                      10987654321098765432109876543210
8209                                                                      000001x01110xxxx111x11xxxxxxxxxx
8210                                                                      uqdecd.  */
8211                                                                   return 1999;
8212                                                                 }
8213                                                             }
8214                                                         }
8215                                                       else
8216                                                         {
8217                                                           if (((word >> 22) & 0x1) == 0)
8218                                                             {
8219                                                               if (((word >> 23) & 0x1) == 0)
8220                                                                 {
8221                                                                   /* 33222222222211111111110000000000
8222                                                                      10987654321098765432109876543210
8223                                                                      000001x00011xxxx111x11xxxxxxxxxx
8224                                                                      uqdecb.  */
8225                                                                   return 1997;
8226                                                                 }
8227                                                               else
8228                                                                 {
8229                                                                   /* 33222222222211111111110000000000
8230                                                                      10987654321098765432109876543210
8231                                                                      000001x01011xxxx111x11xxxxxxxxxx
8232                                                                      uqdecw.  */
8233                                                                   return 2009;
8234                                                                 }
8235                                                             }
8236                                                           else
8237                                                             {
8238                                                               if (((word >> 23) & 0x1) == 0)
8239                                                                 {
8240                                                                   /* 33222222222211111111110000000000
8241                                                                      10987654321098765432109876543210
8242                                                                      000001x00111xxxx111x11xxxxxxxxxx
8243                                                                      uqdech.  */
8244                                                                   return 2003;
8245                                                                 }
8246                                                               else
8247                                                                 {
8248                                                                   /* 33222222222211111111110000000000
8249                                                                      10987654321098765432109876543210
8250                                                                      000001x01111xxxx111x11xxxxxxxxxx
8251                                                                      uqdecd.  */
8252                                                                   return 2000;
8253                                                                 }
8254                                                             }
8255                                                         }
8256                                                     }
8257                                                 }
8258                                             }
8259                                         }
8260                                       else
8261                                         {
8262                                           if (((word >> 22) & 0x1) == 0)
8263                                             {
8264                                               if (((word >> 21) & 0x1) == 0)
8265                                                 {
8266                                                   if (((word >> 23) & 0x1) == 0)
8267                                                     {
8268                                                       /* 33222222222211111111110000000000
8269                                                          10987654321098765432109876543210
8270                                                          100001x0000xxxxx111xxxxxxxxxxxxx
8271                                                          prfb.  */
8272                                                       return 1782;
8273                                                     }
8274                                                   else
8275                                                     {
8276                                                       /* 33222222222211111111110000000000
8277                                                          10987654321098765432109876543210
8278                                                          100001x0100xxxxx111xxxxxxxxxxxxx
8279                                                          prfh.  */
8280                                                       return 1796;
8281                                                     }
8282                                                 }
8283                                               else
8284                                                 {
8285                                                   if (((word >> 23) & 0x1) == 0)
8286                                                     {
8287                                                       /* 33222222222211111111110000000000
8288                                                          10987654321098765432109876543210
8289                                                          100001x0001xxxxx111xxxxxxxxxxxxx
8290                                                          ldff1b.  */
8291                                                       return 1650;
8292                                                     }
8293                                                   else
8294                                                     {
8295                                                       /* 33222222222211111111110000000000
8296                                                          10987654321098765432109876543210
8297                                                          100001x0101xxxxx111xxxxxxxxxxxxx
8298                                                          ldff1h.  */
8299                                                       return 1671;
8300                                                     }
8301                                                 }
8302                                             }
8303                                           else
8304                                             {
8305                                               if (((word >> 23) & 0x1) == 0)
8306                                                 {
8307                                                   /* 33222222222211111111110000000000
8308                                                      10987654321098765432109876543210
8309                                                      100001x001xxxxxx111xxxxxxxxxxxxx
8310                                                      ld1rb.  */
8311                                                   return 1552;
8312                                                 }
8313                                               else
8314                                                 {
8315                                                   /* 33222222222211111111110000000000
8316                                                      10987654321098765432109876543210
8317                                                      100001x011xxxxxx111xxxxxxxxxxxxx
8318                                                      ld1rh.  */
8319                                                   return 1556;
8320                                                 }
8321                                             }
8322                                         }
8323                                     }
8324                                   else
8325                                     {
8326                                       if (((word >> 21) & 0x1) == 0)
8327                                         {
8328                                           if (((word >> 22) & 0x1) == 0)
8329                                             {
8330                                               if (((word >> 23) & 0x1) == 0)
8331                                                 {
8332                                                   /* 33222222222211111111110000000000
8333                                                      10987654321098765432109876543210
8334                                                      x10001x0000xxxxx111xxxxxxxxxxxxx
8335                                                      prfb.  */
8336                                                   return 1784;
8337                                                 }
8338                                               else
8339                                                 {
8340                                                   /* 33222222222211111111110000000000
8341                                                      10987654321098765432109876543210
8342                                                      x10001x0100xxxxx111xxxxxxxxxxxxx
8343                                                      prfh.  */
8344                                                   return 1798;
8345                                                 }
8346                                             }
8347                                           else
8348                                             {
8349                                               if (((word >> 23) & 0x1) == 0)
8350                                                 {
8351                                                   /* 33222222222211111111110000000000
8352                                                      10987654321098765432109876543210
8353                                                      x10001x0010xxxxx111xxxxxxxxxxxxx
8354                                                      ldff1b.  */
8355                                                   return 1649;
8356                                                 }
8357                                               else
8358                                                 {
8359                                                   /* 33222222222211111111110000000000
8360                                                      10987654321098765432109876543210
8361                                                      x10001x0110xxxxx111xxxxxxxxxxxxx
8362                                                      ldff1h.  */
8363                                                   return 1669;
8364                                                 }
8365                                             }
8366                                         }
8367                                       else
8368                                         {
8369                                           if (((word >> 23) & 0x1) == 0)
8370                                             {
8371                                               if (((word >> 31) & 0x1) == 0)
8372                                                 {
8373                                                   if (((word >> 10) & 0x1) == 0)
8374                                                     {
8375                                                       if (((word >> 11) & 0x1) == 0)
8376                                                         {
8377                                                           /* 33222222222211111111110000000000
8378                                                              10987654321098765432109876543210
8379                                                              010001x00x1xxxxx111x00xxxxxxxxxx
8380                                                              sqdmulh.  */
8381                                                           return 2193;
8382                                                         }
8383                                                       else
8384                                                         {
8385                                                           /* 33222222222211111111110000000000
8386                                                              10987654321098765432109876543210
8387                                                              010001x00x1xxxxx111x10xxxxxxxxxx
8388                                                              mul.  */
8389                                                           return 2120;
8390                                                         }
8391                                                     }
8392                                                   else
8393                                                     {
8394                                                       /* 33222222222211111111110000000000
8395                                                          10987654321098765432109876543210
8396                                                          010001x00x1xxxxx111xx1xxxxxxxxxx
8397                                                          sqrdmulh.  */
8398                                                       return 2215;
8399                                                     }
8400                                                 }
8401                                               else
8402                                                 {
8403                                                   if (((word >> 22) & 0x1) == 0)
8404                                                     {
8405                                                       /* 33222222222211111111110000000000
8406                                                          10987654321098765432109876543210
8407                                                          110001x0001xxxxx111xxxxxxxxxxxxx
8408                                                          ldff1b.  */
8409                                                       return 1651;
8410                                                     }
8411                                                   else
8412                                                     {
8413                                                       /* 33222222222211111111110000000000
8414                                                          10987654321098765432109876543210
8415                                                          110001x0011xxxxx111xxxxxxxxxxxxx
8416                                                          prfd.  */
8417                                                       return 1788;
8418                                                     }
8419                                                 }
8420                                             }
8421                                           else
8422                                             {
8423                                               if (((word >> 22) & 0x1) == 0)
8424                                                 {
8425                                                   if (((word >> 31) & 0x1) == 0)
8426                                                     {
8427                                                       if (((word >> 10) & 0x1) == 0)
8428                                                         {
8429                                                           if (((word >> 12) & 0x1) == 0)
8430                                                             {
8431                                                               /* 33222222222211111111110000000000
8432                                                                  10987654321098765432109876543210
8433                                                                  010001x0101xxxxx1110x0xxxxxxxxxx
8434                                                                  sqdmullb.  */
8435                                                               return 2197;
8436                                                             }
8437                                                           else
8438                                                             {
8439                                                               if (((word >> 11) & 0x1) == 0)
8440                                                                 {
8441                                                                   /* 33222222222211111111110000000000
8442                                                                      10987654321098765432109876543210
8443                                                                      010001x0101xxxxx111100xxxxxxxxxx
8444                                                                      sqdmulh.  */
8445                                                                   return 2194;
8446                                                                 }
8447                                                               else
8448                                                                 {
8449                                                                   /* 33222222222211111111110000000000
8450                                                                      10987654321098765432109876543210
8451                                                                      010001x0101xxxxx111110xxxxxxxxxx
8452                                                                      mul.  */
8453                                                                   return 2121;
8454                                                                 }
8455                                                             }
8456                                                         }
8457                                                       else
8458                                                         {
8459                                                           if (((word >> 12) & 0x1) == 0)
8460                                                             {
8461                                                               /* 33222222222211111111110000000000
8462                                                                  10987654321098765432109876543210
8463                                                                  010001x0101xxxxx1110x1xxxxxxxxxx
8464                                                                  sqdmullt.  */
8465                                                               return 2200;
8466                                                             }
8467                                                           else
8468                                                             {
8469                                                               /* 33222222222211111111110000000000
8470                                                                  10987654321098765432109876543210
8471                                                                  010001x0101xxxxx1111x1xxxxxxxxxx
8472                                                                  sqrdmulh.  */
8473                                                               return 2216;
8474                                                             }
8475                                                         }
8476                                                     }
8477                                                   else
8478                                                     {
8479                                                       /* 33222222222211111111110000000000
8480                                                          10987654321098765432109876543210
8481                                                          110001x0101xxxxx111xxxxxxxxxxxxx
8482                                                          ldff1h.  */
8483                                                       return 1672;
8484                                                     }
8485                                                 }
8486                                               else
8487                                                 {
8488                                                   if (((word >> 31) & 0x1) == 0)
8489                                                     {
8490                                                       if (((word >> 10) & 0x1) == 0)
8491                                                         {
8492                                                           if (((word >> 12) & 0x1) == 0)
8493                                                             {
8494                                                               /* 33222222222211111111110000000000
8495                                                                  10987654321098765432109876543210
8496                                                                  010001x0111xxxxx1110x0xxxxxxxxxx
8497                                                                  sqdmullb.  */
8498                                                               return 2198;
8499                                                             }
8500                                                           else
8501                                                             {
8502                                                               if (((word >> 11) & 0x1) == 0)
8503                                                                 {
8504                                                                   /* 33222222222211111111110000000000
8505                                                                      10987654321098765432109876543210
8506                                                                      010001x0111xxxxx111100xxxxxxxxxx
8507                                                                      sqdmulh.  */
8508                                                                   return 2195;
8509                                                                 }
8510                                                               else
8511                                                                 {
8512                                                                   /* 33222222222211111111110000000000
8513                                                                      10987654321098765432109876543210
8514                                                                      010001x0111xxxxx111110xxxxxxxxxx
8515                                                                      mul.  */
8516                                                                   return 2122;
8517                                                                 }
8518                                                             }
8519                                                         }
8520                                                       else
8521                                                         {
8522                                                           if (((word >> 12) & 0x1) == 0)
8523                                                             {
8524                                                               /* 33222222222211111111110000000000
8525                                                                  10987654321098765432109876543210
8526                                                                  010001x0111xxxxx1110x1xxxxxxxxxx
8527                                                                  sqdmullt.  */
8528                                                               return 2201;
8529                                                             }
8530                                                           else
8531                                                             {
8532                                                               /* 33222222222211111111110000000000
8533                                                                  10987654321098765432109876543210
8534                                                                  010001x0111xxxxx1111x1xxxxxxxxxx
8535                                                                  sqrdmulh.  */
8536                                                               return 2217;
8537                                                             }
8538                                                         }
8539                                                     }
8540                                                   else
8541                                                     {
8542                                                       /* 33222222222211111111110000000000
8543                                                          10987654321098765432109876543210
8544                                                          110001x0111xxxxx111xxxxxxxxxxxxx
8545                                                          ldff1h.  */
8546                                                       return 1670;
8547                                                     }
8548                                                 }
8549                                             }
8550                                         }
8551                                     }
8552                                 }
8553                             }
8554                         }
8555                     }
8556                   else
8557                     {
8558                       if (((word >> 21) & 0x1) == 0)
8559                         {
8560                           if (((word >> 15) & 0x1) == 0)
8561                             {
8562                               if (((word >> 30) & 0x1) == 0)
8563                                 {
8564                                   if (((word >> 13) & 0x1) == 0)
8565                                     {
8566                                       if (((word >> 14) & 0x1) == 0)
8567                                         {
8568                                           if (((word >> 31) & 0x1) == 0)
8569                                             {
8570                                               if (((word >> 4) & 0x1) == 0)
8571                                                 {
8572                                                   /* 33222222222211111111110000000000
8573                                                      10987654321098765432109876543210
8574                                                      001001x0xx0xxxxx000xxxxxxxx0xxxx
8575                                                      cmphs.  */
8576                                                   return 1344;
8577                                                 }
8578                                               else
8579                                                 {
8580                                                   /* 33222222222211111111110000000000
8581                                                      10987654321098765432109876543210
8582                                                      001001x0xx0xxxxx000xxxxxxxx1xxxx
8583                                                      cmphi.  */
8584                                                   return 1341;
8585                                                 }
8586                                             }
8587                                           else
8588                                             {
8589                                               if (((word >> 23) & 0x1) == 0)
8590                                                 {
8591                                                   /* 33222222222211111111110000000000
8592                                                      10987654321098765432109876543210
8593                                                      101001x00x0xxxxx000xxxxxxxxxxxxx
8594                                                      ld1rqb.  */
8595                                                   return 1558;
8596                                                 }
8597                                               else
8598                                                 {
8599                                                   /* 33222222222211111111110000000000
8600                                                      10987654321098765432109876543210
8601                                                      101001x01x0xxxxx000xxxxxxxxxxxxx
8602                                                      ld1rqh.  */
8603                                                   return 1562;
8604                                                 }
8605                                             }
8606                                         }
8607                                       else
8608                                         {
8609                                           if (((word >> 31) & 0x1) == 0)
8610                                             {
8611                                               if (((word >> 4) & 0x1) == 0)
8612                                                 {
8613                                                   /* 33222222222211111111110000000000
8614                                                      10987654321098765432109876543210
8615                                                      001001x0xx0xxxxx010xxxxxxxx0xxxx
8616                                                      cmpge.  */
8617                                                   return 1335;
8618                                                 }
8619                                               else
8620                                                 {
8621                                                   /* 33222222222211111111110000000000
8622                                                      10987654321098765432109876543210
8623                                                      001001x0xx0xxxxx010xxxxxxxx1xxxx
8624                                                      cmpgt.  */
8625                                                   return 1338;
8626                                                 }
8627                                             }
8628                                           else
8629                                             {
8630                                               if (((word >> 22) & 0x1) == 0)
8631                                                 {
8632                                                   if (((word >> 23) & 0x1) == 0)
8633                                                     {
8634                                                       /* 33222222222211111111110000000000
8635                                                          10987654321098765432109876543210
8636                                                          101001x0000xxxxx010xxxxxxxxxxxxx
8637                                                          ld1b.  */
8638                                                       return 1516;
8639                                                     }
8640                                                   else
8641                                                     {
8642                                                       /* 33222222222211111111110000000000
8643                                                          10987654321098765432109876543210
8644                                                          101001x0100xxxxx010xxxxxxxxxxxxx
8645                                                          ld1sw.  */
8646                                                       return 1596;
8647                                                     }
8648                                                 }
8649                                               else
8650                                                 {
8651                                                   if (((word >> 23) & 0x1) == 0)
8652                                                     {
8653                                                       /* 33222222222211111111110000000000
8654                                                          10987654321098765432109876543210
8655                                                          101001x0010xxxxx010xxxxxxxxxxxxx
8656                                                          ld1b.  */
8657                                                       return 1518;
8658                                                     }
8659                                                   else
8660                                                     {
8661                                                       /* 33222222222211111111110000000000
8662                                                          10987654321098765432109876543210
8663                                                          101001x0110xxxxx010xxxxxxxxxxxxx
8664                                                          ld1h.  */
8665                                                       return 1538;
8666                                                     }
8667                                                 }
8668                                             }
8669                                         }
8670                                     }
8671                                   else
8672                                     {
8673                                       if (((word >> 14) & 0x1) == 0)
8674                                         {
8675                                           if (((word >> 31) & 0x1) == 0)
8676                                             {
8677                                               if (((word >> 4) & 0x1) == 0)
8678                                                 {
8679                                                   /* 33222222222211111111110000000000
8680                                                      10987654321098765432109876543210
8681                                                      001001x0xx0xxxxx001xxxxxxxx0xxxx
8682                                                      cmpeq.  */
8683                                                   return 1332;
8684                                                 }
8685                                               else
8686                                                 {
8687                                                   /* 33222222222211111111110000000000
8688                                                      10987654321098765432109876543210
8689                                                      001001x0xx0xxxxx001xxxxxxxx1xxxx
8690                                                      cmpne.  */
8691                                                   return 1355;
8692                                                 }
8693                                             }
8694                                           else
8695                                             {
8696                                               if (((word >> 23) & 0x1) == 0)
8697                                                 {
8698                                                   /* 33222222222211111111110000000000
8699                                                      10987654321098765432109876543210
8700                                                      101001x00x0xxxxx001xxxxxxxxxxxxx
8701                                                      ld1rqb.  */
8702                                                   return 1557;
8703                                                 }
8704                                               else
8705                                                 {
8706                                                   /* 33222222222211111111110000000000
8707                                                      10987654321098765432109876543210
8708                                                      101001x01x0xxxxx001xxxxxxxxxxxxx
8709                                                      ld1rqh.  */
8710                                                   return 1561;
8711                                                 }
8712                                             }
8713                                         }
8714                                       else
8715                                         {
8716                                           if (((word >> 31) & 0x1) == 0)
8717                                             {
8718                                               if (((word >> 4) & 0x1) == 0)
8719                                                 {
8720                                                   /* 33222222222211111111110000000000
8721                                                      10987654321098765432109876543210
8722                                                      001001x0xx0xxxxx011xxxxxxxx0xxxx
8723                                                      cmplt.  */
8724                                                   return 1353;
8725                                                 }
8726                                               else
8727                                                 {
8728                                                   /* 33222222222211111111110000000000
8729                                                      10987654321098765432109876543210
8730                                                      001001x0xx0xxxxx011xxxxxxxx1xxxx
8731                                                      cmple.  */
8732                                                   return 1347;
8733                                                 }
8734                                             }
8735                                           else
8736                                             {
8737                                               if (((word >> 22) & 0x1) == 0)
8738                                                 {
8739                                                   if (((word >> 23) & 0x1) == 0)
8740                                                     {
8741                                                       /* 33222222222211111111110000000000
8742                                                          10987654321098765432109876543210
8743                                                          101001x0000xxxxx011xxxxxxxxxxxxx
8744                                                          ldff1b.  */
8745                                                       return 1640;
8746                                                     }
8747                                                   else
8748                                                     {
8749                                                       /* 33222222222211111111110000000000
8750                                                          10987654321098765432109876543210
8751                                                          101001x0100xxxxx011xxxxxxxxxxxxx
8752                                                          ldff1sw.  */
8753                                                       return 1696;
8754                                                     }
8755                                                 }
8756                                               else
8757                                                 {
8758                                                   if (((word >> 23) & 0x1) == 0)
8759                                                     {
8760                                                       /* 33222222222211111111110000000000
8761                                                          10987654321098765432109876543210
8762                                                          101001x0010xxxxx011xxxxxxxxxxxxx
8763                                                          ldff1b.  */
8764                                                       return 1644;
8765                                                     }
8766                                                   else
8767                                                     {
8768                                                       /* 33222222222211111111110000000000
8769                                                          10987654321098765432109876543210
8770                                                          101001x0110xxxxx011xxxxxxxxxxxxx
8771                                                          ldff1h.  */
8772                                                       return 1663;
8773                                                     }
8774                                                 }
8775                                             }
8776                                         }
8777                                     }
8778                                 }
8779                               else
8780                                 {
8781                                   if (((word >> 31) & 0x1) == 0)
8782                                     {
8783                                       /* 33222222222211111111110000000000
8784                                          10987654321098765432109876543210
8785                                          011001x0xx0xxxxx0xxxxxxxxxxxxxxx
8786                                          fcmla.  */
8787                                       return 1401;
8788                                     }
8789                                   else
8790                                     {
8791                                       if (((word >> 13) & 0x1) == 0)
8792                                         {
8793                                           if (((word >> 22) & 0x1) == 0)
8794                                             {
8795                                               /* 33222222222211111111110000000000
8796                                                  10987654321098765432109876543210
8797                                                  111001x0x00xxxxx0x0xxxxxxxxxxxxx
8798                                                  st1b.  */
8799                                               return 1878;
8800                                             }
8801                                           else
8802                                             {
8803                                               if (((word >> 23) & 0x1) == 0)
8804                                                 {
8805                                                   /* 33222222222211111111110000000000
8806                                                      10987654321098765432109876543210
8807                                                      111001x0010xxxxx0x0xxxxxxxxxxxxx
8808                                                      st1b.  */
8809                                                   return 1882;
8810                                                 }
8811                                               else
8812                                                 {
8813                                                   /* 33222222222211111111110000000000
8814                                                      10987654321098765432109876543210
8815                                                      111001x0110xxxxx0x0xxxxxxxxxxxxx
8816                                                      st1h.  */
8817                                                   return 1903;
8818                                                 }
8819                                             }
8820                                         }
8821                                       else
8822                                         {
8823                                           if (((word >> 14) & 0x1) == 0)
8824                                             {
8825                                               if (((word >> 22) & 0x1) == 0)
8826                                                 {
8827                                                   if (((word >> 23) & 0x1) == 0)
8828                                                     {
8829                                                       /* 33222222222211111111110000000000
8830                                                          10987654321098765432109876543210
8831                                                          111001x0000xxxxx001xxxxxxxxxxxxx
8832                                                          stnt1b.  */
8833                                                       return 2255;
8834                                                     }
8835                                                   else
8836                                                     {
8837                                                       /* 33222222222211111111110000000000
8838                                                          10987654321098765432109876543210
8839                                                          111001x0100xxxxx001xxxxxxxxxxxxx
8840                                                          stnt1h.  */
8841                                                       return 2258;
8842                                                     }
8843                                                 }
8844                                               else
8845                                                 {
8846                                                   if (((word >> 23) & 0x1) == 0)
8847                                                     {
8848                                                       /* 33222222222211111111110000000000
8849                                                          10987654321098765432109876543210
8850                                                          111001x0010xxxxx001xxxxxxxxxxxxx
8851                                                          stnt1b.  */
8852                                                       return 2254;
8853                                                     }
8854                                                   else
8855                                                     {
8856                                                       /* 33222222222211111111110000000000
8857                                                          10987654321098765432109876543210
8858                                                          111001x0110xxxxx001xxxxxxxxxxxxx
8859                                                          stnt1h.  */
8860                                                       return 2257;
8861                                                     }
8862                                                 }
8863                                             }
8864                                           else
8865                                             {
8866                                               if (((word >> 22) & 0x1) == 0)
8867                                                 {
8868                                                   if (((word >> 23) & 0x1) == 0)
8869                                                     {
8870                                                       /* 33222222222211111111110000000000
8871                                                          10987654321098765432109876543210
8872                                                          111001x0000xxxxx011xxxxxxxxxxxxx
8873                                                          stnt1b.  */
8874                                                       return 1948;
8875                                                     }
8876                                                   else
8877                                                     {
8878                                                       /* 33222222222211111111110000000000
8879                                                          10987654321098765432109876543210
8880                                                          111001x0100xxxxx011xxxxxxxxxxxxx
8881                                                          stnt1h.  */
8882                                                       return 1952;
8883                                                     }
8884                                                 }
8885                                               else
8886                                                 {
8887                                                   if (((word >> 23) & 0x1) == 0)
8888                                                     {
8889                                                       /* 33222222222211111111110000000000
8890                                                          10987654321098765432109876543210
8891                                                          111001x0010xxxxx011xxxxxxxxxxxxx
8892                                                          st3b.  */
8893                                                       return 1932;
8894                                                     }
8895                                                   else
8896                                                     {
8897                                                       /* 33222222222211111111110000000000
8898                                                          10987654321098765432109876543210
8899                                                          111001x0110xxxxx011xxxxxxxxxxxxx
8900                                                          st3h.  */
8901                                                       return 1936;
8902                                                     }
8903                                                 }
8904                                             }
8905                                         }
8906                                     }
8907                                 }
8908                             }
8909                           else
8910                             {
8911                               if (((word >> 13) & 0x1) == 0)
8912                                 {
8913                                   if (((word >> 30) & 0x1) == 0)
8914                                     {
8915                                       if (((word >> 14) & 0x1) == 0)
8916                                         {
8917                                           if (((word >> 4) & 0x1) == 0)
8918                                             {
8919                                               /* 33222222222211111111110000000000
8920                                                  10987654321098765432109876543210
8921                                                  x01001x0xx0xxxxx100xxxxxxxx0xxxx
8922                                                  cmpge.  */
8923                                               return 1336;
8924                                             }
8925                                           else
8926                                             {
8927                                               /* 33222222222211111111110000000000
8928                                                  10987654321098765432109876543210
8929                                                  x01001x0xx0xxxxx100xxxxxxxx1xxxx
8930                                                  cmpgt.  */
8931                                               return 1339;
8932                                             }
8933                                         }
8934                                       else
8935                                         {
8936                                           if (((word >> 31) & 0x1) == 0)
8937                                             {
8938                                               if (((word >> 4) & 0x1) == 0)
8939                                                 {
8940                                                   /* 33222222222211111111110000000000
8941                                                      10987654321098765432109876543210
8942                                                      001001x0xx0xxxxx110xxxxxxxx0xxxx
8943                                                      cmphs.  */
8944                                                   return 1345;
8945                                                 }
8946                                               else
8947                                                 {
8948                                                   /* 33222222222211111111110000000000
8949                                                      10987654321098765432109876543210
8950                                                      001001x0xx0xxxxx110xxxxxxxx1xxxx
8951                                                      cmphi.  */
8952                                                   return 1342;
8953                                                 }
8954                                             }
8955                                           else
8956                                             {
8957                                               if (((word >> 22) & 0x1) == 0)
8958                                                 {
8959                                                   if (((word >> 23) & 0x1) == 0)
8960                                                     {
8961                                                       /* 33222222222211111111110000000000
8962                                                          10987654321098765432109876543210
8963                                                          101001x0000xxxxx110xxxxxxxxxxxxx
8964                                                          ldnt1b.  */
8965                                                       return 1731;
8966                                                     }
8967                                                   else
8968                                                     {
8969                                                       /* 33222222222211111111110000000000
8970                                                          10987654321098765432109876543210
8971                                                          101001x0100xxxxx110xxxxxxxxxxxxx
8972                                                          ldnt1h.  */
8973                                                       return 1735;
8974                                                     }
8975                                                 }
8976                                               else
8977                                                 {
8978                                                   if (((word >> 23) & 0x1) == 0)
8979                                                     {
8980                                                       /* 33222222222211111111110000000000
8981                                                          10987654321098765432109876543210
8982                                                          101001x0010xxxxx110xxxxxxxxxxxxx
8983                                                          ld3b.  */
8984                                                       return 1623;
8985                                                     }
8986                                                   else
8987                                                     {
8988                                                       /* 33222222222211111111110000000000
8989                                                          10987654321098765432109876543210
8990                                                          101001x0110xxxxx110xxxxxxxxxxxxx
8991                                                          ld3h.  */
8992                                                       return 1627;
8993                                                     }
8994                                                 }
8995                                             }
8996                                         }
8997                                     }
8998                                   else
8999                                     {
9000                                       if (((word >> 31) & 0x1) == 0)
9001                                         {
9002                                           if (((word >> 17) & 0x1) == 0)
9003                                             {
9004                                               if (((word >> 18) & 0x1) == 0)
9005                                                 {
9006                                                   if (((word >> 20) & 0x1) == 0)
9007                                                     {
9008                                                       /* 33222222222211111111110000000000
9009                                                          10987654321098765432109876543210
9010                                                          011001x0xx00x00x1x0xxxxxxxxxxxxx
9011                                                          fcadd.  */
9012                                                       return 1400;
9013                                                     }
9014                                                   else
9015                                                     {
9016                                                       /* 33222222222211111111110000000000
9017                                                          10987654321098765432109876543210
9018                                                          011001x0xx01x00x1x0xxxxxxxxxxxxx
9019                                                          faddp.  */
9020                                                       return 2081;
9021                                                     }
9022                                                 }
9023                                               else
9024                                                 {
9025                                                   if (((word >> 16) & 0x1) == 0)
9026                                                     {
9027                                                       /* 33222222222211111111110000000000
9028                                                          10987654321098765432109876543210
9029                                                          011001x0xx0xx1001x0xxxxxxxxxxxxx
9030                                                          fmaxnmp.  */
9031                                                       return 2089;
9032                                                     }
9033                                                   else
9034                                                     {
9035                                                       /* 33222222222211111111110000000000
9036                                                          10987654321098765432109876543210
9037                                                          011001x0xx0xx1011x0xxxxxxxxxxxxx
9038                                                          fminnmp.  */
9039                                                       return 2091;
9040                                                     }
9041                                                 }
9042                                             }
9043                                           else
9044                                             {
9045                                               if (((word >> 16) & 0x1) == 0)
9046                                                 {
9047                                                   /* 33222222222211111111110000000000
9048                                                      10987654321098765432109876543210
9049                                                      011001x0xx0xxx101x0xxxxxxxxxxxxx
9050                                                      fmaxp.  */
9051                                                   return 2090;
9052                                                 }
9053                                               else
9054                                                 {
9055                                                   /* 33222222222211111111110000000000
9056                                                      10987654321098765432109876543210
9057                                                      011001x0xx0xxx111x0xxxxxxxxxxxxx
9058                                                      fminp.  */
9059                                                   return 2092;
9060                                                 }
9061                                             }
9062                                         }
9063                                       else
9064                                         {
9065                                           if (((word >> 22) & 0x1) == 0)
9066                                             {
9067                                               if (((word >> 23) & 0x1) == 0)
9068                                                 {
9069                                                   /* 33222222222211111111110000000000
9070                                                      10987654321098765432109876543210
9071                                                      111001x0000xxxxx1x0xxxxxxxxxxxxx
9072                                                      st1b.  */
9073                                                   return 1879;
9074                                                 }
9075                                               else
9076                                                 {
9077                                                   /* 33222222222211111111110000000000
9078                                                      10987654321098765432109876543210
9079                                                      111001x0100xxxxx1x0xxxxxxxxxxxxx
9080                                                      st1h.  */
9081                                                   return 1898;
9082                                                 }
9083                                             }
9084                                           else
9085                                             {
9086                                               if (((word >> 23) & 0x1) == 0)
9087                                                 {
9088                                                   /* 33222222222211111111110000000000
9089                                                      10987654321098765432109876543210
9090                                                      111001x0010xxxxx1x0xxxxxxxxxxxxx
9091                                                      st1b.  */
9092                                                   return 1883;
9093                                                 }
9094                                               else
9095                                                 {
9096                                                   /* 33222222222211111111110000000000
9097                                                      10987654321098765432109876543210
9098                                                      111001x0110xxxxx1x0xxxxxxxxxxxxx
9099                                                      st1h.  */
9100                                                   return 1904;
9101                                                 }
9102                                             }
9103                                         }
9104                                     }
9105                                 }
9106                               else
9107                                 {
9108                                   if (((word >> 14) & 0x1) == 0)
9109                                     {
9110                                       if (((word >> 30) & 0x1) == 0)
9111                                         {
9112                                           if (((word >> 31) & 0x1) == 0)
9113                                             {
9114                                               if (((word >> 4) & 0x1) == 0)
9115                                                 {
9116                                                   /* 33222222222211111111110000000000
9117                                                      10987654321098765432109876543210
9118                                                      001001x0xx0xxxxx101xxxxxxxx0xxxx
9119                                                      cmpeq.  */
9120                                                   return 1333;
9121                                                 }
9122                                               else
9123                                                 {
9124                                                   /* 33222222222211111111110000000000
9125                                                      10987654321098765432109876543210
9126                                                      001001x0xx0xxxxx101xxxxxxxx1xxxx
9127                                                      cmpne.  */
9128                                                   return 1356;
9129                                                 }
9130                                             }
9131                                           else
9132                                             {
9133                                               if (((word >> 20) & 0x1) == 0)
9134                                                 {
9135                                                   if (((word >> 22) & 0x1) == 0)
9136                                                     {
9137                                                       if (((word >> 23) & 0x1) == 0)
9138                                                         {
9139                                                           /* 33222222222211111111110000000000
9140                                                              10987654321098765432109876543210
9141                                                              101001x00000xxxx101xxxxxxxxxxxxx
9142                                                              ld1b.  */
9143                                                           return 1523;
9144                                                         }
9145                                                       else
9146                                                         {
9147                                                           /* 33222222222211111111110000000000
9148                                                              10987654321098765432109876543210
9149                                                              101001x01000xxxx101xxxxxxxxxxxxx
9150                                                              ld1sw.  */
9151                                                           return 1601;
9152                                                         }
9153                                                     }
9154                                                   else
9155                                                     {
9156                                                       if (((word >> 23) & 0x1) == 0)
9157                                                         {
9158                                                           /* 33222222222211111111110000000000
9159                                                              10987654321098765432109876543210
9160                                                              101001x00100xxxx101xxxxxxxxxxxxx
9161                                                              ld1b.  */
9162                                                           return 1525;
9163                                                         }
9164                                                       else
9165                                                         {
9166                                                           /* 33222222222211111111110000000000
9167                                                              10987654321098765432109876543210
9168                                                              101001x01100xxxx101xxxxxxxxxxxxx
9169                                                              ld1h.  */
9170                                                           return 1546;
9171                                                         }
9172                                                     }
9173                                                 }
9174                                               else
9175                                                 {
9176                                                   if (((word >> 22) & 0x1) == 0)
9177                                                     {
9178                                                       if (((word >> 23) & 0x1) == 0)
9179                                                         {
9180                                                           /* 33222222222211111111110000000000
9181                                                              10987654321098765432109876543210
9182                                                              101001x00001xxxx101xxxxxxxxxxxxx
9183                                                              ldnf1b.  */
9184                                                           return 1715;
9185                                                         }
9186                                                       else
9187                                                         {
9188                                                           /* 33222222222211111111110000000000
9189                                                              10987654321098765432109876543210
9190                                                              101001x01001xxxx101xxxxxxxxxxxxx
9191                                                              ldnf1sw.  */
9192                                                           return 1728;
9193                                                         }
9194                                                     }
9195                                                   else
9196                                                     {
9197                                                       if (((word >> 23) & 0x1) == 0)
9198                                                         {
9199                                                           /* 33222222222211111111110000000000
9200                                                              10987654321098765432109876543210
9201                                                              101001x00101xxxx101xxxxxxxxxxxxx
9202                                                              ldnf1b.  */
9203                                                           return 1717;
9204                                                         }
9205                                                       else
9206                                                         {
9207                                                           /* 33222222222211111111110000000000
9208                                                              10987654321098765432109876543210
9209                                                              101001x01101xxxx101xxxxxxxxxxxxx
9210                                                              ldnf1h.  */
9211                                                           return 1721;
9212                                                         }
9213                                                     }
9214                                                 }
9215                                             }
9216                                         }
9217                                       else
9218                                         {
9219                                           if (((word >> 22) & 0x1) == 0)
9220                                             {
9221                                               if (((word >> 23) & 0x1) == 0)
9222                                                 {
9223                                                   if (((word >> 31) & 0x1) == 0)
9224                                                     {
9225                                                       /* 33222222222211111111110000000000
9226                                                          10987654321098765432109876543210
9227                                                          011001x0000xxxxx101xxxxxxxxxxxxx
9228                                                          fcvtxnt.  */
9229                                                       return 2087;
9230                                                     }
9231                                                   else
9232                                                     {
9233                                                       /* 33222222222211111111110000000000
9234                                                          10987654321098765432109876543210
9235                                                          111001x0000xxxxx101xxxxxxxxxxxxx
9236                                                          st1b.  */
9237                                                       return 1880;
9238                                                     }
9239                                                 }
9240                                               else
9241                                                 {
9242                                                   if (((word >> 31) & 0x1) == 0)
9243                                                     {
9244                                                       if (((word >> 16) & 0x1) == 0)
9245                                                         {
9246                                                           if (((word >> 17) & 0x1) == 0)
9247                                                             {
9248                                                               /* 33222222222211111111110000000000
9249                                                                  10987654321098765432109876543210
9250                                                                  011001x0100xxx00101xxxxxxxxxxxxx
9251                                                                  fcvtnt.  */
9252                                                               return 2084;
9253                                                             }
9254                                                           else
9255                                                             {
9256                                                               /* 33222222222211111111110000000000
9257                                                                  10987654321098765432109876543210
9258                                                                  011001x0100xxx10101xxxxxxxxxxxxx
9259                                                                  bfcvtnt.  */
9260                                                               return 2496;
9261                                                             }
9262                                                         }
9263                                                       else
9264                                                         {
9265                                                           /* 33222222222211111111110000000000
9266                                                              10987654321098765432109876543210
9267                                                              011001x0100xxxx1101xxxxxxxxxxxxx
9268                                                              fcvtlt.  */
9269                                                           return 2082;
9270                                                         }
9271                                                     }
9272                                                   else
9273                                                     {
9274                                                       /* 33222222222211111111110000000000
9275                                                          10987654321098765432109876543210
9276                                                          111001x0100xxxxx101xxxxxxxxxxxxx
9277                                                          st1h.  */
9278                                                       return 1899;
9279                                                     }
9280                                                 }
9281                                             }
9282                                           else
9283                                             {
9284                                               if (((word >> 23) & 0x1) == 0)
9285                                                 {
9286                                                   /* 33222222222211111111110000000000
9287                                                      10987654321098765432109876543210
9288                                                      x11001x0010xxxxx101xxxxxxxxxxxxx
9289                                                      st1b.  */
9290                                                   return 1887;
9291                                                 }
9292                                               else
9293                                                 {
9294                                                   if (((word >> 31) & 0x1) == 0)
9295                                                     {
9296                                                       if (((word >> 16) & 0x1) == 0)
9297                                                         {
9298                                                           /* 33222222222211111111110000000000
9299                                                              10987654321098765432109876543210
9300                                                              011001x0110xxxx0101xxxxxxxxxxxxx
9301                                                              fcvtnt.  */
9302                                                           return 2085;
9303                                                         }
9304                                                       else
9305                                                         {
9306                                                           /* 33222222222211111111110000000000
9307                                                              10987654321098765432109876543210
9308                                                              011001x0110xxxx1101xxxxxxxxxxxxx
9309                                                              fcvtlt.  */
9310                                                           return 2083;
9311                                                         }
9312                                                     }
9313                                                   else
9314                                                     {
9315                                                       /* 33222222222211111111110000000000
9316                                                          10987654321098765432109876543210
9317                                                          111001x0110xxxxx101xxxxxxxxxxxxx
9318                                                          st1h.  */
9319                                                       return 1908;
9320                                                     }
9321                                                 }
9322                                             }
9323                                         }
9324                                     }
9325                                   else
9326                                     {
9327                                       if (((word >> 30) & 0x1) == 0)
9328                                         {
9329                                           if (((word >> 31) & 0x1) == 0)
9330                                             {
9331                                               if (((word >> 4) & 0x1) == 0)
9332                                                 {
9333                                                   /* 33222222222211111111110000000000
9334                                                      10987654321098765432109876543210
9335                                                      001001x0xx0xxxxx111xxxxxxxx0xxxx
9336                                                      cmplo.  */
9337                                                   return 1349;
9338                                                 }
9339                                               else
9340                                                 {
9341                                                   /* 33222222222211111111110000000000
9342                                                      10987654321098765432109876543210
9343                                                      001001x0xx0xxxxx111xxxxxxxx1xxxx
9344                                                      cmpls.  */
9345                                                   return 1351;
9346                                                 }
9347                                             }
9348                                           else
9349                                             {
9350                                               if (((word >> 22) & 0x1) == 0)
9351                                                 {
9352                                                   if (((word >> 23) & 0x1) == 0)
9353                                                     {
9354                                                       /* 33222222222211111111110000000000
9355                                                          10987654321098765432109876543210
9356                                                          101001x0000xxxxx111xxxxxxxxxxxxx
9357                                                          ldnt1b.  */
9358                                                       return 1732;
9359                                                     }
9360                                                   else
9361                                                     {
9362                                                       /* 33222222222211111111110000000000
9363                                                          10987654321098765432109876543210
9364                                                          101001x0100xxxxx111xxxxxxxxxxxxx
9365                                                          ldnt1h.  */
9366                                                       return 1736;
9367                                                     }
9368                                                 }
9369                                               else
9370                                                 {
9371                                                   if (((word >> 23) & 0x1) == 0)
9372                                                     {
9373                                                       /* 33222222222211111111110000000000
9374                                                          10987654321098765432109876543210
9375                                                          101001x0010xxxxx111xxxxxxxxxxxxx
9376                                                          ld3b.  */
9377                                                       return 1624;
9378                                                     }
9379                                                   else
9380                                                     {
9381                                                       /* 33222222222211111111110000000000
9382                                                          10987654321098765432109876543210
9383                                                          101001x0110xxxxx111xxxxxxxxxxxxx
9384                                                          ld3h.  */
9385                                                       return 1628;
9386                                                     }
9387                                                 }
9388                                             }
9389                                         }
9390                                       else
9391                                         {
9392                                           if (((word >> 20) & 0x1) == 0)
9393                                             {
9394                                               if (((word >> 22) & 0x1) == 0)
9395                                                 {
9396                                                   /* 33222222222211111111110000000000
9397                                                      10987654321098765432109876543210
9398                                                      x11001x0x000xxxx111xxxxxxxxxxxxx
9399                                                      st1b.  */
9400                                                   return 1885;
9401                                                 }
9402                                               else
9403                                                 {
9404                                                   if (((word >> 23) & 0x1) == 0)
9405                                                     {
9406                                                       /* 33222222222211111111110000000000
9407                                                          10987654321098765432109876543210
9408                                                          x11001x00100xxxx111xxxxxxxxxxxxx
9409                                                          st1b.  */
9410                                                       return 1888;
9411                                                     }
9412                                                   else
9413                                                     {
9414                                                       /* 33222222222211111111110000000000
9415                                                          10987654321098765432109876543210
9416                                                          x11001x01100xxxx111xxxxxxxxxxxxx
9417                                                          st1h.  */
9418                                                       return 1909;
9419                                                     }
9420                                                 }
9421                                             }
9422                                           else
9423                                             {
9424                                               if (((word >> 22) & 0x1) == 0)
9425                                                 {
9426                                                   if (((word >> 23) & 0x1) == 0)
9427                                                     {
9428                                                       /* 33222222222211111111110000000000
9429                                                          10987654321098765432109876543210
9430                                                          x11001x00001xxxx111xxxxxxxxxxxxx
9431                                                          stnt1b.  */
9432                                                       return 1949;
9433                                                     }
9434                                                   else
9435                                                     {
9436                                                       /* 33222222222211111111110000000000
9437                                                          10987654321098765432109876543210
9438                                                          x11001x01001xxxx111xxxxxxxxxxxxx
9439                                                          stnt1h.  */
9440                                                       return 1953;
9441                                                     }
9442                                                 }
9443                                               else
9444                                                 {
9445                                                   if (((word >> 23) & 0x1) == 0)
9446                                                     {
9447                                                       /* 33222222222211111111110000000000
9448                                                          10987654321098765432109876543210
9449                                                          x11001x00101xxxx111xxxxxxxxxxxxx
9450                                                          st3b.  */
9451                                                       return 1933;
9452                                                     }
9453                                                   else
9454                                                     {
9455                                                       /* 33222222222211111111110000000000
9456                                                          10987654321098765432109876543210
9457                                                          x11001x01101xxxx111xxxxxxxxxxxxx
9458                                                          st3h.  */
9459                                                       return 1937;
9460                                                     }
9461                                                 }
9462                                             }
9463                                         }
9464                                     }
9465                                 }
9466                             }
9467                         }
9468                       else
9469                         {
9470                           if (((word >> 13) & 0x1) == 0)
9471                             {
9472                               if (((word >> 30) & 0x1) == 0)
9473                                 {
9474                                   if (((word >> 31) & 0x1) == 0)
9475                                     {
9476                                       if (((word >> 4) & 0x1) == 0)
9477                                         {
9478                                           /* 33222222222211111111110000000000
9479                                              10987654321098765432109876543210
9480                                              001001x0xx1xxxxxxx0xxxxxxxx0xxxx
9481                                              cmphs.  */
9482                                           return 1346;
9483                                         }
9484                                       else
9485                                         {
9486                                           /* 33222222222211111111110000000000
9487                                              10987654321098765432109876543210
9488                                              001001x0xx1xxxxxxx0xxxxxxxx1xxxx
9489                                              cmphi.  */
9490                                           return 1343;
9491                                         }
9492                                     }
9493                                   else
9494                                     {
9495                                       if (((word >> 14) & 0x1) == 0)
9496                                         {
9497                                           if (((word >> 23) & 0x1) == 0)
9498                                             {
9499                                               /* 33222222222211111111110000000000
9500                                                  10987654321098765432109876543210
9501                                                  101001x00x1xxxxxx00xxxxxxxxxxxxx
9502                                                  ld1rob.  */
9503                                               return 2472;
9504                                             }
9505                                           else
9506                                             {
9507                                               /* 33222222222211111111110000000000
9508                                                  10987654321098765432109876543210
9509                                                  101001x01x1xxxxxx00xxxxxxxxxxxxx
9510                                                  ld1roh.  */
9511                                               return 2473;
9512                                             }
9513                                         }
9514                                       else
9515                                         {
9516                                           if (((word >> 15) & 0x1) == 0)
9517                                             {
9518                                               if (((word >> 22) & 0x1) == 0)
9519                                                 {
9520                                                   if (((word >> 23) & 0x1) == 0)
9521                                                     {
9522                                                       /* 33222222222211111111110000000000
9523                                                          10987654321098765432109876543210
9524                                                          101001x0001xxxxx010xxxxxxxxxxxxx
9525                                                          ld1b.  */
9526                                                       return 1517;
9527                                                     }
9528                                                   else
9529                                                     {
9530                                                       /* 33222222222211111111110000000000
9531                                                          10987654321098765432109876543210
9532                                                          101001x0101xxxxx010xxxxxxxxxxxxx
9533                                                          ld1h.  */
9534                                                       return 1537;
9535                                                     }
9536                                                 }
9537                                               else
9538                                                 {
9539                                                   if (((word >> 23) & 0x1) == 0)
9540                                                     {
9541                                                       /* 33222222222211111111110000000000
9542                                                          10987654321098765432109876543210
9543                                                          101001x0011xxxxx010xxxxxxxxxxxxx
9544                                                          ld1b.  */
9545                                                       return 1519;
9546                                                     }
9547                                                   else
9548                                                     {
9549                                                       /* 33222222222211111111110000000000
9550                                                          10987654321098765432109876543210
9551                                                          101001x0111xxxxx010xxxxxxxxxxxxx
9552                                                          ld1h.  */
9553                                                       return 1539;
9554                                                     }
9555                                                 }
9556                                             }
9557                                           else
9558                                             {
9559                                               if (((word >> 22) & 0x1) == 0)
9560                                                 {
9561                                                   if (((word >> 23) & 0x1) == 0)
9562                                                     {
9563                                                       /* 33222222222211111111110000000000
9564                                                          10987654321098765432109876543210
9565                                                          101001x0001xxxxx110xxxxxxxxxxxxx
9566                                                          ld2b.  */
9567                                                       return 1615;
9568                                                     }
9569                                                   else
9570                                                     {
9571                                                       /* 33222222222211111111110000000000
9572                                                          10987654321098765432109876543210
9573                                                          101001x0101xxxxx110xxxxxxxxxxxxx
9574                                                          ld2h.  */
9575                                                       return 1619;
9576                                                     }
9577                                                 }
9578                                               else
9579                                                 {
9580                                                   if (((word >> 23) & 0x1) == 0)
9581                                                     {
9582                                                       /* 33222222222211111111110000000000
9583                                                          10987654321098765432109876543210
9584                                                          101001x0011xxxxx110xxxxxxxxxxxxx
9585                                                          ld4b.  */
9586                                                       return 1631;
9587                                                     }
9588                                                   else
9589                                                     {
9590                                                       /* 33222222222211111111110000000000
9591                                                          10987654321098765432109876543210
9592                                                          101001x0111xxxxx110xxxxxxxxxxxxx
9593                                                          ld4h.  */
9594                                                       return 1635;
9595                                                     }
9596                                                 }
9597                                             }
9598                                         }
9599                                     }
9600                                 }
9601                               else
9602                                 {
9603                                   if (((word >> 15) & 0x1) == 0)
9604                                     {
9605                                       if (((word >> 14) & 0x1) == 0)
9606                                         {
9607                                           if (((word >> 12) & 0x1) == 0)
9608                                             {
9609                                               if (((word >> 10) & 0x1) == 0)
9610                                                 {
9611                                                   if (((word >> 23) & 0x1) == 0)
9612                                                     {
9613                                                       /* 33222222222211111111110000000000
9614                                                          10987654321098765432109876543210
9615                                                          x11001x00x1xxxxx0000x0xxxxxxxxxx
9616                                                          fmla.  */
9617                                                       return 1454;
9618                                                     }
9619                                                   else
9620                                                     {
9621                                                       if (((word >> 22) & 0x1) == 0)
9622                                                         {
9623                                                           /* 33222222222211111111110000000000
9624                                                              10987654321098765432109876543210
9625                                                              x11001x0101xxxxx0000x0xxxxxxxxxx
9626                                                              fmla.  */
9627                                                           return 1455;
9628                                                         }
9629                                                       else
9630                                                         {
9631                                                           /* 33222222222211111111110000000000
9632                                                              10987654321098765432109876543210
9633                                                              x11001x0111xxxxx0000x0xxxxxxxxxx
9634                                                              fmla.  */
9635                                                           return 1456;
9636                                                         }
9637                                                     }
9638                                                 }
9639                                               else
9640                                                 {
9641                                                   if (((word >> 23) & 0x1) == 0)
9642                                                     {
9643                                                       /* 33222222222211111111110000000000
9644                                                          10987654321098765432109876543210
9645                                                          x11001x00x1xxxxx0000x1xxxxxxxxxx
9646                                                          fmls.  */
9647                                                       return 1458;
9648                                                     }
9649                                                   else
9650                                                     {
9651                                                       if (((word >> 22) & 0x1) == 0)
9652                                                         {
9653                                                           /* 33222222222211111111110000000000
9654                                                              10987654321098765432109876543210
9655                                                              x11001x0101xxxxx0000x1xxxxxxxxxx
9656                                                              fmls.  */
9657                                                           return 1459;
9658                                                         }
9659                                                       else
9660                                                         {
9661                                                           /* 33222222222211111111110000000000
9662                                                              10987654321098765432109876543210
9663                                                              x11001x0111xxxxx0000x1xxxxxxxxxx
9664                                                              fmls.  */
9665                                                           return 1460;
9666                                                         }
9667                                                     }
9668                                                 }
9669                                             }
9670                                           else
9671                                             {
9672                                               if (((word >> 22) & 0x1) == 0)
9673                                                 {
9674                                                   /* 33222222222211111111110000000000
9675                                                      10987654321098765432109876543210
9676                                                      x11001x0x01xxxxx0001xxxxxxxxxxxx
9677                                                      fcmla.  */
9678                                                   return 1402;
9679                                                 }
9680                                               else
9681                                                 {
9682                                                   /* 33222222222211111111110000000000
9683                                                      10987654321098765432109876543210
9684                                                      x11001x0x11xxxxx0001xxxxxxxxxxxx
9685                                                      fcmla.  */
9686                                                   return 1403;
9687                                                 }
9688                                             }
9689                                         }
9690                                       else
9691                                         {
9692                                           if (((word >> 22) & 0x1) == 0)
9693                                             {
9694                                               if (((word >> 23) & 0x1) == 0)
9695                                                 {
9696                                                   /* 33222222222211111111110000000000
9697                                                      10987654321098765432109876543210
9698                                                      x11001x0001xxxxx010xxxxxxxxxxxxx
9699                                                      st1b.  */
9700                                                   return 1881;
9701                                                 }
9702                                               else
9703                                                 {
9704                                                   if (((word >> 31) & 0x1) == 0)
9705                                                     {
9706                                                       if (((word >> 10) & 0x1) == 0)
9707                                                         {
9708                                                           /* 33222222222211111111110000000000
9709                                                              10987654321098765432109876543210
9710                                                              011001x0101xxxxx010xx0xxxxxxxxxx
9711                                                              fmlalb.  */
9712                                                           return 2093;
9713                                                         }
9714                                                       else
9715                                                         {
9716                                                           /* 33222222222211111111110000000000
9717                                                              10987654321098765432109876543210
9718                                                              011001x0101xxxxx010xx1xxxxxxxxxx
9719                                                              fmlalt.  */
9720                                                           return 2095;
9721                                                         }
9722                                                     }
9723                                                   else
9724                                                     {
9725                                                       /* 33222222222211111111110000000000
9726                                                          10987654321098765432109876543210
9727                                                          111001x0101xxxxx010xxxxxxxxxxxxx
9728                                                          st1h.  */
9729                                                       return 1900;
9730                                                     }
9731                                                 }
9732                                             }
9733                                           else
9734                                             {
9735                                               if (((word >> 23) & 0x1) == 0)
9736                                                 {
9737                                                   if (((word >> 31) & 0x1) == 0)
9738                                                     {
9739                                                       /* 33222222222211111111110000000000
9740                                                          10987654321098765432109876543210
9741                                                          011001x0011xxxxx010xxxxxxxxxxxxx
9742                                                          bfdot.  */
9743                                                       return 2493;
9744                                                     }
9745                                                   else
9746                                                     {
9747                                                       /* 33222222222211111111110000000000
9748                                                          10987654321098765432109876543210
9749                                                          111001x0011xxxxx010xxxxxxxxxxxxx
9750                                                          st1b.  */
9751                                                       return 1884;
9752                                                     }
9753                                                 }
9754                                               else
9755                                                 {
9756                                                   if (((word >> 31) & 0x1) == 0)
9757                                                     {
9758                                                       if (((word >> 10) & 0x1) == 0)
9759                                                         {
9760                                                           /* 33222222222211111111110000000000
9761                                                              10987654321098765432109876543210
9762                                                              011001x0111xxxxx010xx0xxxxxxxxxx
9763                                                              bfmlalb.  */
9764                                                           return 2500;
9765                                                         }
9766                                                       else
9767                                                         {
9768                                                           /* 33222222222211111111110000000000
9769                                                              10987654321098765432109876543210
9770                                                              011001x0111xxxxx010xx1xxxxxxxxxx
9771                                                              bfmlalt.  */
9772                                                           return 2499;
9773                                                         }
9774                                                     }
9775                                                   else
9776                                                     {
9777                                                       /* 33222222222211111111110000000000
9778                                                          10987654321098765432109876543210
9779                                                          111001x0111xxxxx010xxxxxxxxxxxxx
9780                                                          st1h.  */
9781                                                       return 1905;
9782                                                     }
9783                                                 }
9784                                             }
9785                                         }
9786                                     }
9787                                   else
9788                                     {
9789                                       if (((word >> 22) & 0x1) == 0)
9790                                         {
9791                                           if (((word >> 31) & 0x1) == 0)
9792                                             {
9793                                               if (((word >> 10) & 0x1) == 0)
9794                                                 {
9795                                                   /* 33222222222211111111110000000000
9796                                                      10987654321098765432109876543210
9797                                                      011001x0x01xxxxx1x0xx0xxxxxxxxxx
9798                                                      fmlalb.  */
9799                                                   return 2094;
9800                                                 }
9801                                               else
9802                                                 {
9803                                                   /* 33222222222211111111110000000000
9804                                                      10987654321098765432109876543210
9805                                                      011001x0x01xxxxx1x0xx1xxxxxxxxxx
9806                                                      fmlalt.  */
9807                                                   return 2096;
9808                                                 }
9809                                             }
9810                                           else
9811                                             {
9812                                               /* 33222222222211111111110000000000
9813                                                  10987654321098765432109876543210
9814                                                  111001x0x01xxxxx1x0xxxxxxxxxxxxx
9815                                                  st1h.  */
9816                                               return 1901;
9817                                             }
9818                                         }
9819                                       else
9820                                         {
9821                                           if (((word >> 23) & 0x1) == 0)
9822                                             {
9823                                               /* 33222222222211111111110000000000
9824                                                  10987654321098765432109876543210
9825                                                  x11001x0011xxxxx1x0xxxxxxxxxxxxx
9826                                                  bfdot.  */
9827                                               return 2492;
9828                                             }
9829                                           else
9830                                             {
9831                                               if (((word >> 31) & 0x1) == 0)
9832                                                 {
9833                                                   if (((word >> 10) & 0x1) == 0)
9834                                                     {
9835                                                       /* 33222222222211111111110000000000
9836                                                          10987654321098765432109876543210
9837                                                          011001x0111xxxxx1x0xx0xxxxxxxxxx
9838                                                          bfmlalb.  */
9839                                                       return 2498;
9840                                                     }
9841                                                   else
9842                                                     {
9843                                                       /* 33222222222211111111110000000000
9844                                                          10987654321098765432109876543210
9845                                                          011001x0111xxxxx1x0xx1xxxxxxxxxx
9846                                                          bfmlalt.  */
9847                                                       return 2497;
9848                                                     }
9849                                                 }
9850                                               else
9851                                                 {
9852                                                   /* 33222222222211111111110000000000
9853                                                      10987654321098765432109876543210
9854                                                      111001x0111xxxxx1x0xxxxxxxxxxxxx
9855                                                      st1h.  */
9856                                                   return 1906;
9857                                                 }
9858                                             }
9859                                         }
9860                                     }
9861                                 }
9862                             }
9863                           else
9864                             {
9865                               if (((word >> 30) & 0x1) == 0)
9866                                 {
9867                                   if (((word >> 31) & 0x1) == 0)
9868                                     {
9869                                       if (((word >> 4) & 0x1) == 0)
9870                                         {
9871                                           /* 33222222222211111111110000000000
9872                                              10987654321098765432109876543210
9873                                              001001x0xx1xxxxxxx1xxxxxxxx0xxxx
9874                                              cmplo.  */
9875                                           return 1350;
9876                                         }
9877                                       else
9878                                         {
9879                                           /* 33222222222211111111110000000000
9880                                              10987654321098765432109876543210
9881                                              001001x0xx1xxxxxxx1xxxxxxxx1xxxx
9882                                              cmpls.  */
9883                                           return 1352;
9884                                         }
9885                                     }
9886                                   else
9887                                     {
9888                                       if (((word >> 14) & 0x1) == 0)
9889                                         {
9890                                           if (((word >> 15) & 0x1) == 0)
9891                                             {
9892                                               if (((word >> 23) & 0x1) == 0)
9893                                                 {
9894                                                   /* 33222222222211111111110000000000
9895                                                      10987654321098765432109876543210
9896                                                      101001x00x1xxxxx001xxxxxxxxxxxxx
9897                                                      ld1rob.  */
9898                                                   return 2476;
9899                                                 }
9900                                               else
9901                                                 {
9902                                                   /* 33222222222211111111110000000000
9903                                                      10987654321098765432109876543210
9904                                                      101001x01x1xxxxx001xxxxxxxxxxxxx
9905                                                      ld1roh.  */
9906                                                   return 2477;
9907                                                 }
9908                                             }
9909                                           else
9910                                             {
9911                                               if (((word >> 20) & 0x1) == 0)
9912                                                 {
9913                                                   if (((word >> 22) & 0x1) == 0)
9914                                                     {
9915                                                       if (((word >> 23) & 0x1) == 0)
9916                                                         {
9917                                                           /* 33222222222211111111110000000000
9918                                                              10987654321098765432109876543210
9919                                                              101001x00010xxxx101xxxxxxxxxxxxx
9920                                                              ld1b.  */
9921                                                           return 1524;
9922                                                         }
9923                                                       else
9924                                                         {
9925                                                           /* 33222222222211111111110000000000
9926                                                              10987654321098765432109876543210
9927                                                              101001x01010xxxx101xxxxxxxxxxxxx
9928                                                              ld1h.  */
9929                                                           return 1545;
9930                                                         }
9931                                                     }
9932                                                   else
9933                                                     {
9934                                                       if (((word >> 23) & 0x1) == 0)
9935                                                         {
9936                                                           /* 33222222222211111111110000000000
9937                                                              10987654321098765432109876543210
9938                                                              101001x00110xxxx101xxxxxxxxxxxxx
9939                                                              ld1b.  */
9940                                                           return 1526;
9941                                                         }
9942                                                       else
9943                                                         {
9944                                                           /* 33222222222211111111110000000000
9945                                                              10987654321098765432109876543210
9946                                                              101001x01110xxxx101xxxxxxxxxxxxx
9947                                                              ld1h.  */
9948                                                           return 1547;
9949                                                         }
9950                                                     }
9951                                                 }
9952                                               else
9953                                                 {
9954                                                   if (((word >> 22) & 0x1) == 0)
9955                                                     {
9956                                                       if (((word >> 23) & 0x1) == 0)
9957                                                         {
9958                                                           /* 33222222222211111111110000000000
9959                                                              10987654321098765432109876543210
9960                                                              101001x00011xxxx101xxxxxxxxxxxxx
9961                                                              ldnf1b.  */
9962                                                           return 1716;
9963                                                         }
9964                                                       else
9965                                                         {
9966                                                           /* 33222222222211111111110000000000
9967                                                              10987654321098765432109876543210
9968                                                              101001x01011xxxx101xxxxxxxxxxxxx
9969                                                              ldnf1h.  */
9970                                                           return 1720;
9971                                                         }
9972                                                     }
9973                                                   else
9974                                                     {
9975                                                       if (((word >> 23) & 0x1) == 0)
9976                                                         {
9977                                                           /* 33222222222211111111110000000000
9978                                                              10987654321098765432109876543210
9979                                                              101001x00111xxxx101xxxxxxxxxxxxx
9980                                                              ldnf1b.  */
9981                                                           return 1718;
9982                                                         }
9983                                                       else
9984                                                         {
9985                                                           /* 33222222222211111111110000000000
9986                                                              10987654321098765432109876543210
9987                                                              101001x01111xxxx101xxxxxxxxxxxxx
9988                                                              ldnf1h.  */
9989                                                           return 1722;
9990                                                         }
9991                                                     }
9992                                                 }
9993                                             }
9994                                         }
9995                                       else
9996                                         {
9997                                           if (((word >> 15) & 0x1) == 0)
9998                                             {
9999                                               if (((word >> 22) & 0x1) == 0)
10000                                                 {
10001                                                   if (((word >> 23) & 0x1) == 0)
10002                                                     {
10003                                                       /* 33222222222211111111110000000000
10004                                                          10987654321098765432109876543210
10005                                                          101001x0001xxxxx011xxxxxxxxxxxxx
10006                                                          ldff1b.  */
10007                                                       return 1642;
10008                                                     }
10009                                                   else
10010                                                     {
10011                                                       /* 33222222222211111111110000000000
10012                                                          10987654321098765432109876543210
10013                                                          101001x0101xxxxx011xxxxxxxxxxxxx
10014                                                          ldff1h.  */
10015                                                       return 1661;
10016                                                     }
10017                                                 }
10018                                               else
10019                                                 {
10020                                                   if (((word >> 23) & 0x1) == 0)
10021                                                     {
10022                                                       /* 33222222222211111111110000000000
10023                                                          10987654321098765432109876543210
10024                                                          101001x0011xxxxx011xxxxxxxxxxxxx
10025                                                          ldff1b.  */
10026                                                       return 1646;
10027                                                     }
10028                                                   else
10029                                                     {
10030                                                       /* 33222222222211111111110000000000
10031                                                          10987654321098765432109876543210
10032                                                          101001x0111xxxxx011xxxxxxxxxxxxx
10033                                                          ldff1h.  */
10034                                                       return 1665;
10035                                                     }
10036                                                 }
10037                                             }
10038                                           else
10039                                             {
10040                                               if (((word >> 22) & 0x1) == 0)
10041                                                 {
10042                                                   if (((word >> 23) & 0x1) == 0)
10043                                                     {
10044                                                       /* 33222222222211111111110000000000
10045                                                          10987654321098765432109876543210
10046                                                          101001x0001xxxxx111xxxxxxxxxxxxx
10047                                                          ld2b.  */
10048                                                       return 1616;
10049                                                     }
10050                                                   else
10051                                                     {
10052                                                       /* 33222222222211111111110000000000
10053                                                          10987654321098765432109876543210
10054                                                          101001x0101xxxxx111xxxxxxxxxxxxx
10055                                                          ld2h.  */
10056                                                       return 1620;
10057                                                     }
10058                                                 }
10059                                               else
10060                                                 {
10061                                                   if (((word >> 23) & 0x1) == 0)
10062                                                     {
10063                                                       /* 33222222222211111111110000000000
10064                                                          10987654321098765432109876543210
10065                                                          101001x0011xxxxx111xxxxxxxxxxxxx
10066                                                          ld4b.  */
10067                                                       return 1632;
10068                                                     }
10069                                                   else
10070                                                     {
10071                                                       /* 33222222222211111111110000000000
10072                                                          10987654321098765432109876543210
10073                                                          101001x0111xxxxx111xxxxxxxxxxxxx
10074                                                          ld4h.  */
10075                                                       return 1636;
10076                                                     }
10077                                                 }
10078                                             }
10079                                         }
10080                                     }
10081                                 }
10082                               else
10083                                 {
10084                                   if (((word >> 14) & 0x1) == 0)
10085                                     {
10086                                       if (((word >> 15) & 0x1) == 0)
10087                                         {
10088                                           if (((word >> 23) & 0x1) == 0)
10089                                             {
10090                                               /* 33222222222211111111110000000000
10091                                                  10987654321098765432109876543210
10092                                                  x11001x00x1xxxxx001xxxxxxxxxxxxx
10093                                                  fmul.  */
10094                                               return 1465;
10095                                             }
10096                                           else
10097                                             {
10098                                               if (((word >> 22) & 0x1) == 0)
10099                                                 {
10100                                                   /* 33222222222211111111110000000000
10101                                                      10987654321098765432109876543210
10102                                                      x11001x0101xxxxx001xxxxxxxxxxxxx
10103                                                      fmul.  */
10104                                                   return 1466;
10105                                                 }
10106                                               else
10107                                                 {
10108                                                   /* 33222222222211111111110000000000
10109                                                      10987654321098765432109876543210
10110                                                      x11001x0111xxxxx001xxxxxxxxxxxxx
10111                                                      fmul.  */
10112                                                   return 1467;
10113                                                 }
10114                                             }
10115                                         }
10116                                       else
10117                                         {
10118                                           if (((word >> 22) & 0x1) == 0)
10119                                             {
10120                                               if (((word >> 31) & 0x1) == 0)
10121                                                 {
10122                                                   if (((word >> 10) & 0x1) == 0)
10123                                                     {
10124                                                       /* 33222222222211111111110000000000
10125                                                          10987654321098765432109876543210
10126                                                          011001x0x01xxxxx101xx0xxxxxxxxxx
10127                                                          fmlslb.  */
10128                                                       return 2098;
10129                                                     }
10130                                                   else
10131                                                     {
10132                                                       /* 33222222222211111111110000000000
10133                                                          10987654321098765432109876543210
10134                                                          011001x0x01xxxxx101xx1xxxxxxxxxx
10135                                                          fmlslt.  */
10136                                                       return 2100;
10137                                                     }
10138                                                 }
10139                                               else
10140                                                 {
10141                                                   /* 33222222222211111111110000000000
10142                                                      10987654321098765432109876543210
10143                                                      111001x0x01xxxxx101xxxxxxxxxxxxx
10144                                                      st1h.  */
10145                                                   return 1902;
10146                                                 }
10147                                             }
10148                                           else
10149                                             {
10150                                               if (((word >> 23) & 0x1) == 0)
10151                                                 {
10152                                                   /* 33222222222211111111110000000000
10153                                                      10987654321098765432109876543210
10154                                                      x11001x0011xxxxx101xxxxxxxxxxxxx
10155                                                      st1b.  */
10156                                                   return 1889;
10157                                                 }
10158                                               else
10159                                                 {
10160                                                   /* 33222222222211111111110000000000
10161                                                      10987654321098765432109876543210
10162                                                      x11001x0111xxxxx101xxxxxxxxxxxxx
10163                                                      st1h.  */
10164                                                   return 1910;
10165                                                 }
10166                                             }
10167                                         }
10168                                     }
10169                                   else
10170                                     {
10171                                       if (((word >> 15) & 0x1) == 0)
10172                                         {
10173                                           if (((word >> 22) & 0x1) == 0)
10174                                             {
10175                                               if (((word >> 23) & 0x1) == 0)
10176                                                 {
10177                                                   /* 33222222222211111111110000000000
10178                                                      10987654321098765432109876543210
10179                                                      x11001x0001xxxxx011xxxxxxxxxxxxx
10180                                                      st2b.  */
10181                                                   return 1924;
10182                                                 }
10183                                               else
10184                                                 {
10185                                                   if (((word >> 31) & 0x1) == 0)
10186                                                     {
10187                                                       if (((word >> 10) & 0x1) == 0)
10188                                                         {
10189                                                           /* 33222222222211111111110000000000
10190                                                              10987654321098765432109876543210
10191                                                              011001x0101xxxxx011xx0xxxxxxxxxx
10192                                                              fmlslb.  */
10193                                                           return 2097;
10194                                                         }
10195                                                       else
10196                                                         {
10197                                                           /* 33222222222211111111110000000000
10198                                                              10987654321098765432109876543210
10199                                                              011001x0101xxxxx011xx1xxxxxxxxxx
10200                                                              fmlslt.  */
10201                                                           return 2099;
10202                                                         }
10203                                                     }
10204                                                   else
10205                                                     {
10206                                                       /* 33222222222211111111110000000000
10207                                                          10987654321098765432109876543210
10208                                                          111001x0101xxxxx011xxxxxxxxxxxxx
10209                                                          st2h.  */
10210                                                       return 1928;
10211                                                     }
10212                                                 }
10213                                             }
10214                                           else
10215                                             {
10216                                               if (((word >> 23) & 0x1) == 0)
10217                                                 {
10218                                                   /* 33222222222211111111110000000000
10219                                                      10987654321098765432109876543210
10220                                                      x11001x0011xxxxx011xxxxxxxxxxxxx
10221                                                      st4b.  */
10222                                                   return 1940;
10223                                                 }
10224                                               else
10225                                                 {
10226                                                   /* 33222222222211111111110000000000
10227                                                      10987654321098765432109876543210
10228                                                      x11001x0111xxxxx011xxxxxxxxxxxxx
10229                                                      st4h.  */
10230                                                   return 1944;
10231                                                 }
10232                                             }
10233                                         }
10234                                       else
10235                                         {
10236                                           if (((word >> 22) & 0x1) == 0)
10237                                             {
10238                                               if (((word >> 23) & 0x1) == 0)
10239                                                 {
10240                                                   if (((word >> 20) & 0x1) == 0)
10241                                                     {
10242                                                       /* 33222222222211111111110000000000
10243                                                          10987654321098765432109876543210
10244                                                          x11001x00010xxxx111xxxxxxxxxxxxx
10245                                                          st1b.  */
10246                                                       return 1886;
10247                                                     }
10248                                                   else
10249                                                     {
10250                                                       /* 33222222222211111111110000000000
10251                                                          10987654321098765432109876543210
10252                                                          x11001x00011xxxx111xxxxxxxxxxxxx
10253                                                          st2b.  */
10254                                                       return 1925;
10255                                                     }
10256                                                 }
10257                                               else
10258                                                 {
10259                                                   if (((word >> 31) & 0x1) == 0)
10260                                                     {
10261                                                       /* 33222222222211111111110000000000
10262                                                          10987654321098765432109876543210
10263                                                          011001x0101xxxxx111xxxxxxxxxxxxx
10264                                                          fmmla.  */
10265                                                       return 2470;
10266                                                     }
10267                                                   else
10268                                                     {
10269                                                       if (((word >> 20) & 0x1) == 0)
10270                                                         {
10271                                                           /* 33222222222211111111110000000000
10272                                                              10987654321098765432109876543210
10273                                                              111001x01010xxxx111xxxxxxxxxxxxx
10274                                                              st1h.  */
10275                                                           return 1907;
10276                                                         }
10277                                                       else
10278                                                         {
10279                                                           /* 33222222222211111111110000000000
10280                                                              10987654321098765432109876543210
10281                                                              111001x01011xxxx111xxxxxxxxxxxxx
10282                                                              st2h.  */
10283                                                           return 1929;
10284                                                         }
10285                                                     }
10286                                                 }
10287                                             }
10288                                           else
10289                                             {
10290                                               if (((word >> 23) & 0x1) == 0)
10291                                                 {
10292                                                   if (((word >> 31) & 0x1) == 0)
10293                                                     {
10294                                                       /* 33222222222211111111110000000000
10295                                                          10987654321098765432109876543210
10296                                                          011001x0011xxxxx111xxxxxxxxxxxxx
10297                                                          bfmmla.  */
10298                                                       return 2494;
10299                                                     }
10300                                                   else
10301                                                     {
10302                                                       if (((word >> 20) & 0x1) == 0)
10303                                                         {
10304                                                           /* 33222222222211111111110000000000
10305                                                              10987654321098765432109876543210
10306                                                              111001x00110xxxx111xxxxxxxxxxxxx
10307                                                              st1b.  */
10308                                                           return 1890;
10309                                                         }
10310                                                       else
10311                                                         {
10312                                                           /* 33222222222211111111110000000000
10313                                                              10987654321098765432109876543210
10314                                                              111001x00111xxxx111xxxxxxxxxxxxx
10315                                                              st4b.  */
10316                                                           return 1941;
10317                                                         }
10318                                                     }
10319                                                 }
10320                                               else
10321                                                 {
10322                                                   if (((word >> 31) & 0x1) == 0)
10323                                                     {
10324                                                       /* 33222222222211111111110000000000
10325                                                          10987654321098765432109876543210
10326                                                          011001x0111xxxxx111xxxxxxxxxxxxx
10327                                                          fmmla.  */
10328                                                       return 2471;
10329                                                     }
10330                                                   else
10331                                                     {
10332                                                       if (((word >> 20) & 0x1) == 0)
10333                                                         {
10334                                                           /* 33222222222211111111110000000000
10335                                                              10987654321098765432109876543210
10336                                                              111001x01110xxxx111xxxxxxxxxxxxx
10337                                                              st1h.  */
10338                                                           return 1911;
10339                                                         }
10340                                                       else
10341                                                         {
10342                                                           /* 33222222222211111111110000000000
10343                                                              10987654321098765432109876543210
10344                                                              111001x01111xxxx111xxxxxxxxxxxxx
10345                                                              st4h.  */
10346                                                           return 1945;
10347                                                         }
10348                                                     }
10349                                                 }
10350                                             }
10351                                         }
10352                                     }
10353                                 }
10354                             }
10355                         }
10356                     }
10357                 }
10358               else
10359                 {
10360                   if (((word >> 29) & 0x1) == 0)
10361                     {
10362                       if (((word >> 30) & 0x1) == 0)
10363                         {
10364                           if (((word >> 31) & 0x1) == 0)
10365                             {
10366                               if (((word >> 21) & 0x1) == 0)
10367                                 {
10368                                   if (((word >> 20) & 0x1) == 0)
10369                                     {
10370                                       if (((word >> 22) & 0x1) == 0)
10371                                         {
10372                                           if (((word >> 23) & 0x1) == 0)
10373                                             {
10374                                               /* 33222222222211111111110000000000
10375                                                  10987654321098765432109876543210
10376                                                  000001x10000xxxxxxxxxxxxxxxxxxxx
10377                                                  orr.  */
10378                                               return 1770;
10379                                             }
10380                                           else
10381                                             {
10382                                               /* 33222222222211111111110000000000
10383                                                  10987654321098765432109876543210
10384                                                  000001x11000xxxxxxxxxxxxxxxxxxxx
10385                                                  and.  */
10386                                               return 1298;
10387                                             }
10388                                         }
10389                                       else
10390                                         {
10391                                           if (((word >> 23) & 0x1) == 0)
10392                                             {
10393                                               /* 33222222222211111111110000000000
10394                                                  10987654321098765432109876543210
10395                                                  000001x10100xxxxxxxxxxxxxxxxxxxx
10396                                                  eor.  */
10397                                               return 1385;
10398                                             }
10399                                           else
10400                                             {
10401                                               /* 33222222222211111111110000000000
10402                                                  10987654321098765432109876543210
10403                                                  000001x11100xxxxxxxxxxxxxxxxxxxx
10404                                                  dupm.  */
10405                                               return 1383;
10406                                             }
10407                                         }
10408                                     }
10409                                   else
10410                                     {
10411                                       if (((word >> 15) & 0x1) == 0)
10412                                         {
10413                                           /* 33222222222211111111110000000000
10414                                              10987654321098765432109876543210
10415                                              000001x1xx01xxxx0xxxxxxxxxxxxxxx
10416                                              cpy.  */
10417                                           return 1368;
10418                                         }
10419                                       else
10420                                         {
10421                                           /* 33222222222211111111110000000000
10422                                              10987654321098765432109876543210
10423                                              000001x1xx01xxxx1xxxxxxxxxxxxxxx
10424                                              fcpy.  */
10425                                           return 1415;
10426                                         }
10427                                     }
10428                                 }
10429                               else
10430                                 {
10431                                   if (((word >> 14) & 0x1) == 0)
10432                                     {
10433                                       if (((word >> 13) & 0x1) == 0)
10434                                         {
10435                                           if (((word >> 15) & 0x1) == 0)
10436                                             {
10437                                               if (((word >> 22) & 0x1) == 0)
10438                                                 {
10439                                                   if (((word >> 23) & 0x1) == 0)
10440                                                     {
10441                                                       /* 33222222222211111111110000000000
10442                                                          10987654321098765432109876543210
10443                                                          000001x1001xxxxx000xxxxxxxxxxxxx
10444                                                          ext.  */
10445                                                       return 1390;
10446                                                     }
10447                                                   else
10448                                                     {
10449                                                       if (((word >> 10) & 0x1) == 0)
10450                                                         {
10451                                                           if (((word >> 11) & 0x1) == 0)
10452                                                             {
10453                                                               /* 33222222222211111111110000000000
10454                                                                  10987654321098765432109876543210
10455                                                                  000001x1101xxxxx000x00xxxxxxxxxx
10456                                                                  zip1.  */
10457                                                               return 2480;
10458                                                             }
10459                                                           else
10460                                                             {
10461                                                               if (((word >> 12) & 0x1) == 0)
10462                                                                 {
10463                                                                   /* 33222222222211111111110000000000
10464                                                                      10987654321098765432109876543210
10465                                                                      000001x1101xxxxx000010xxxxxxxxxx
10466                                                                      uzp1.  */
10467                                                                   return 2482;
10468                                                                 }
10469                                                               else
10470                                                                 {
10471                                                                   /* 33222222222211111111110000000000
10472                                                                      10987654321098765432109876543210
10473                                                                      000001x1101xxxxx000110xxxxxxxxxx
10474                                                                      trn1.  */
10475                                                                   return 2484;
10476                                                                 }
10477                                                             }
10478                                                         }
10479                                                       else
10480                                                         {
10481                                                           if (((word >> 11) & 0x1) == 0)
10482                                                             {
10483                                                               /* 33222222222211111111110000000000
10484                                                                  10987654321098765432109876543210
10485                                                                  000001x1101xxxxx000x01xxxxxxxxxx
10486                                                                  zip2.  */
10487                                                               return 2481;
10488                                                             }
10489                                                           else
10490                                                             {
10491                                                               if (((word >> 12) & 0x1) == 0)
10492                                                                 {
10493                                                                   /* 33222222222211111111110000000000
10494                                                                      10987654321098765432109876543210
10495                                                                      000001x1101xxxxx000011xxxxxxxxxx
10496                                                                      uzp2.  */
10497                                                                   return 2483;
10498                                                                 }
10499                                                               else
10500                                                                 {
10501                                                                   /* 33222222222211111111110000000000
10502                                                                      10987654321098765432109876543210
10503                                                                      000001x1101xxxxx000111xxxxxxxxxx
10504                                                                      trn2.  */
10505                                                                   return 2485;
10506                                                                 }
10507                                                             }
10508                                                         }
10509                                                     }
10510                                                 }
10511                                               else
10512                                                 {
10513                                                   /* 33222222222211111111110000000000
10514                                                      10987654321098765432109876543210
10515                                                      000001x1x11xxxxx000xxxxxxxxxxxxx
10516                                                      ext.  */
10517                                                   return 2080;
10518                                                 }
10519                                             }
10520                                           else
10521                                             {
10522                                               if (((word >> 16) & 0x1) == 0)
10523                                                 {
10524                                                   if (((word >> 17) & 0x1) == 0)
10525                                                     {
10526                                                       if (((word >> 18) & 0x1) == 0)
10527                                                         {
10528                                                           if (((word >> 19) & 0x1) == 0)
10529                                                             {
10530                                                               /* 33222222222211111111110000000000
10531                                                                  10987654321098765432109876543210
10532                                                                  000001x1xx1x0000100xxxxxxxxxxxxx
10533                                                                  cpy.  */
10534                                                               return 1366;
10535                                                             }
10536                                                           else
10537                                                             {
10538                                                               /* 33222222222211111111110000000000
10539                                                                  10987654321098765432109876543210
10540                                                                  000001x1xx1x1000100xxxxxxxxxxxxx
10541                                                                  clasta.  */
10542                                                               return 1324;
10543                                                             }
10544                                                         }
10545                                                       else
10546                                                         {
10547                                                           if (((word >> 19) & 0x1) == 0)
10548                                                             {
10549                                                               /* 33222222222211111111110000000000
10550                                                                  10987654321098765432109876543210
10551                                                                  000001x1xx1x0100100xxxxxxxxxxxxx
10552                                                                  revb.  */
10553                                                               return 1818;
10554                                                             }
10555                                                           else
10556                                                             {
10557                                                               /* 33222222222211111111110000000000
10558                                                                  10987654321098765432109876543210
10559                                                                  000001x1xx1x1100100xxxxxxxxxxxxx
10560                                                                  splice.  */
10561                                                               return 1845;
10562                                                             }
10563                                                         }
10564                                                     }
10565                                                   else
10566                                                     {
10567                                                       if (((word >> 18) & 0x1) == 0)
10568                                                         {
10569                                                           if (((word >> 19) & 0x1) == 0)
10570                                                             {
10571                                                               /* 33222222222211111111110000000000
10572                                                                  10987654321098765432109876543210
10573                                                                  000001x1xx1x0010100xxxxxxxxxxxxx
10574                                                                  lasta.  */
10575                                                               return 1512;
10576                                                             }
10577                                                           else
10578                                                             {
10579                                                               /* 33222222222211111111110000000000
10580                                                                  10987654321098765432109876543210
10581                                                                  000001x1xx1x1010100xxxxxxxxxxxxx
10582                                                                  clasta.  */
10583                                                               return 1325;
10584                                                             }
10585                                                         }
10586                                                       else
10587                                                         {
10588                                                           if (((word >> 19) & 0x1) == 0)
10589                                                             {
10590                                                               /* 33222222222211111111110000000000
10591                                                                  10987654321098765432109876543210
10592                                                                  000001x1xx1x0110100xxxxxxxxxxxxx
10593                                                                  revw.  */
10594                                                               return 1820;
10595                                                             }
10596                                                           else
10597                                                             {
10598                                                               /* 33222222222211111111110000000000
10599                                                                  10987654321098765432109876543210
10600                                                                  000001x1xx1x1110100xxxxxxxxxxxxx
10601                                                                  revd.  */
10602                                                               return 2407;
10603                                                             }
10604                                                         }
10605                                                     }
10606                                                 }
10607                                               else
10608                                                 {
10609                                                   if (((word >> 17) & 0x1) == 0)
10610                                                     {
10611                                                       if (((word >> 18) & 0x1) == 0)
10612                                                         {
10613                                                           if (((word >> 19) & 0x1) == 0)
10614                                                             {
10615                                                               /* 33222222222211111111110000000000
10616                                                                  10987654321098765432109876543210
10617                                                                  000001x1xx1x0001100xxxxxxxxxxxxx
10618                                                                  compact.  */
10619                                                               return 1365;
10620                                                             }
10621                                                           else
10622                                                             {
10623                                                               /* 33222222222211111111110000000000
10624                                                                  10987654321098765432109876543210
10625                                                                  000001x1xx1x1001100xxxxxxxxxxxxx
10626                                                                  clastb.  */
10627                                                               return 1327;
10628                                                             }
10629                                                         }
10630                                                       else
10631                                                         {
10632                                                           if (((word >> 19) & 0x1) == 0)
10633                                                             {
10634                                                               /* 33222222222211111111110000000000
10635                                                                  10987654321098765432109876543210
10636                                                                  000001x1xx1x0101100xxxxxxxxxxxxx
10637                                                                  revh.  */
10638                                                               return 1819;
10639                                                             }
10640                                                           else
10641                                                             {
10642                                                               /* 33222222222211111111110000000000
10643                                                                  10987654321098765432109876543210
10644                                                                  000001x1xx1x1101100xxxxxxxxxxxxx
10645                                                                  splice.  */
10646                                                               return 2175;
10647                                                             }
10648                                                         }
10649                                                     }
10650                                                   else
10651                                                     {
10652                                                       if (((word >> 18) & 0x1) == 0)
10653                                                         {
10654                                                           if (((word >> 19) & 0x1) == 0)
10655                                                             {
10656                                                               /* 33222222222211111111110000000000
10657                                                                  10987654321098765432109876543210
10658                                                                  000001x1xx1x0011100xxxxxxxxxxxxx
10659                                                                  lastb.  */
10660                                                               return 1514;
10661                                                             }
10662                                                           else
10663                                                             {
10664                                                               /* 33222222222211111111110000000000
10665                                                                  10987654321098765432109876543210
10666                                                                  000001x1xx1x1011100xxxxxxxxxxxxx
10667                                                                  clastb.  */
10668                                                               return 1328;
10669                                                             }
10670                                                         }
10671                                                       else
10672                                                         {
10673                                                           /* 33222222222211111111110000000000
10674                                                              10987654321098765432109876543210
10675                                                              000001x1xx1xx111100xxxxxxxxxxxxx
10676                                                              rbit.  */
10677                                                           return 1811;
10678                                                         }
10679                                                     }
10680                                                 }
10681                                             }
10682                                         }
10683                                       else
10684                                         {
10685                                           if (((word >> 15) & 0x1) == 0)
10686                                             {
10687                                               if (((word >> 10) & 0x1) == 0)
10688                                                 {
10689                                                   if (((word >> 11) & 0x1) == 0)
10690                                                     {
10691                                                       if (((word >> 12) & 0x1) == 0)
10692                                                         {
10693                                                           /* 33222222222211111111110000000000
10694                                                              10987654321098765432109876543210
10695                                                              000001x1xx1xxxxx001000xxxxxxxxxx
10696                                                              dup.  */
10697                                                           return 1381;
10698                                                         }
10699                                                       else
10700                                                         {
10701                                                           /* 33222222222211111111110000000000
10702                                                              10987654321098765432109876543210
10703                                                              000001x1xx1xxxxx001100xxxxxxxxxx
10704                                                              tbl.  */
10705                                                           return 1968;
10706                                                         }
10707                                                     }
10708                                                   else
10709                                                     {
10710                                                       if (((word >> 12) & 0x1) == 0)
10711                                                         {
10712                                                           /* 33222222222211111111110000000000
10713                                                              10987654321098765432109876543210
10714                                                              000001x1xx1xxxxx001010xxxxxxxxxx
10715                                                              tbl.  */
10716                                                           return 2264;
10717                                                         }
10718                                                       else
10719                                                         {
10720                                                           if (((word >> 16) & 0x1) == 0)
10721                                                             {
10722                                                               if (((word >> 17) & 0x1) == 0)
10723                                                                 {
10724                                                                   if (((word >> 18) & 0x1) == 0)
10725                                                                     {
10726                                                                       if (((word >> 19) & 0x1) == 0)
10727                                                                         {
10728                                                                           if (((word >> 20) & 0x1) == 0)
10729                                                                             {
10730                                                                               /* 33222222222211111111110000000000
10731                                                                                  10987654321098765432109876543210
10732                                                                                  000001x1xx100000001110xxxxxxxxxx
10733                                                                                  dup.  */
10734                                                                               return 1380;
10735                                                                             }
10736                                                                           else
10737                                                                             {
10738                                                                               /* 33222222222211111111110000000000
10739                                                                                  10987654321098765432109876543210
10740                                                                                  000001x1xx110000001110xxxxxxxxxx
10741                                                                                  sunpklo.  */
10742                                                                               return 1964;
10743                                                                             }
10744                                                                         }
10745                                                                       else
10746                                                                         {
10747                                                                           /* 33222222222211111111110000000000
10748                                                                              10987654321098765432109876543210
10749                                                                              000001x1xx1x1000001110xxxxxxxxxx
10750                                                                              rev.  */
10751                                                                           return 1817;
10752                                                                         }
10753                                                                     }
10754                                                                   else
10755                                                                     {
10756                                                                       if (((word >> 20) & 0x1) == 0)
10757                                                                         {
10758                                                                           /* 33222222222211111111110000000000
10759                                                                              10987654321098765432109876543210
10760                                                                              000001x1xx10x100001110xxxxxxxxxx
10761                                                                              insr.  */
10762                                                                           return 1509;
10763                                                                         }
10764                                                                       else
10765                                                                         {
10766                                                                           /* 33222222222211111111110000000000
10767                                                                              10987654321098765432109876543210
10768                                                                              000001x1xx11x100001110xxxxxxxxxx
10769                                                                              insr.  */
10770                                                                           return 1510;
10771                                                                         }
10772                                                                     }
10773                                                                 }
10774                                                               else
10775                                                                 {
10776                                                                   /* 33222222222211111111110000000000
10777                                                                      10987654321098765432109876543210
10778                                                                      000001x1xx1xxx10001110xxxxxxxxxx
10779                                                                      uunpklo.  */
10780                                                                   return 2027;
10781                                                                 }
10782                                                             }
10783                                                           else
10784                                                             {
10785                                                               if (((word >> 17) & 0x1) == 0)
10786                                                                 {
10787                                                                   /* 33222222222211111111110000000000
10788                                                                      10987654321098765432109876543210
10789                                                                      000001x1xx1xxx01001110xxxxxxxxxx
10790                                                                      sunpkhi.  */
10791                                                                   return 1963;
10792                                                                 }
10793                                                               else
10794                                                                 {
10795                                                                   /* 33222222222211111111110000000000
10796                                                                      10987654321098765432109876543210
10797                                                                      000001x1xx1xxx11001110xxxxxxxxxx
10798                                                                      uunpkhi.  */
10799                                                                   return 2026;
10800                                                                 }
10801                                                             }
10802                                                         }
10803                                                     }
10804                                                 }
10805                                               else
10806                                                 {
10807                                                   /* 33222222222211111111110000000000
10808                                                      10987654321098765432109876543210
10809                                                      000001x1xx1xxxxx001xx1xxxxxxxxxx
10810                                                      tbx.  */
10811                                                   return 2265;
10812                                                 }
10813                                             }
10814                                           else
10815                                             {
10816                                               if (((word >> 16) & 0x1) == 0)
10817                                                 {
10818                                                   if (((word >> 19) & 0x1) == 0)
10819                                                     {
10820                                                       if (((word >> 20) & 0x1) == 0)
10821                                                         {
10822                                                           /* 33222222222211111111110000000000
10823                                                              10987654321098765432109876543210
10824                                                              000001x1xx100xx0101xxxxxxxxxxxxx
10825                                                              lasta.  */
10826                                                           return 1511;
10827                                                         }
10828                                                       else
10829                                                         {
10830                                                           /* 33222222222211111111110000000000
10831                                                              10987654321098765432109876543210
10832                                                              000001x1xx110xx0101xxxxxxxxxxxxx
10833                                                              clasta.  */
10834                                                           return 1326;
10835                                                         }
10836                                                     }
10837                                                   else
10838                                                     {
10839                                                       /* 33222222222211111111110000000000
10840                                                          10987654321098765432109876543210
10841                                                          000001x1xx1x1xx0101xxxxxxxxxxxxx
10842                                                          cpy.  */
10843                                                       return 1367;
10844                                                     }
10845                                                 }
10846                                               else
10847                                                 {
10848                                                   if (((word >> 20) & 0x1) == 0)
10849                                                     {
10850                                                       /* 33222222222211111111110000000000
10851                                                          10987654321098765432109876543210
10852                                                          000001x1xx10xxx1101xxxxxxxxxxxxx
10853                                                          lastb.  */
10854                                                       return 1513;
10855                                                     }
10856                                                   else
10857                                                     {
10858                                                       /* 33222222222211111111110000000000
10859                                                          10987654321098765432109876543210
10860                                                          000001x1xx11xxx1101xxxxxxxxxxxxx
10861                                                          clastb.  */
10862                                                       return 1329;
10863                                                     }
10864                                                 }
10865                                             }
10866                                         }
10867                                     }
10868                                   else
10869                                     {
10870                                       if (((word >> 15) & 0x1) == 0)
10871                                         {
10872                                           if (((word >> 10) & 0x1) == 0)
10873                                             {
10874                                               if (((word >> 11) & 0x1) == 0)
10875                                                 {
10876                                                   if (((word >> 12) & 0x1) == 0)
10877                                                     {
10878                                                       if (((word >> 13) & 0x1) == 0)
10879                                                         {
10880                                                           if (((word >> 20) & 0x1) == 0)
10881                                                             {
10882                                                               /* 33222222222211111111110000000000
10883                                                                  10987654321098765432109876543210
10884                                                                  000001x1xx10xxxx010000xxxxxxxxxx
10885                                                                  zip1.  */
10886                                                               return 2044;
10887                                                             }
10888                                                           else
10889                                                             {
10890                                                               if (((word >> 16) & 0x1) == 0)
10891                                                                 {
10892                                                                   if (((word >> 18) & 0x1) == 0)
10893                                                                     {
10894                                                                       /* 33222222222211111111110000000000
10895                                                                          10987654321098765432109876543210
10896                                                                          000001x1xx11x0x0010000xxxxxxxxxx
10897                                                                          punpklo.  */
10898                                                                       return 1810;
10899                                                                     }
10900                                                                   else
10901                                                                     {
10902                                                                       /* 33222222222211111111110000000000
10903                                                                          10987654321098765432109876543210
10904                                                                          000001x1xx11x1x0010000xxxxxxxxxx
10905                                                                          rev.  */
10906                                                                       return 1816;
10907                                                                     }
10908                                                                 }
10909                                                               else
10910                                                                 {
10911                                                                   /* 33222222222211111111110000000000
10912                                                                      10987654321098765432109876543210
10913                                                                      000001x1xx11xxx1010000xxxxxxxxxx
10914                                                                      punpkhi.  */
10915                                                                   return 1809;
10916                                                                 }
10917                                                             }
10918                                                         }
10919                                                       else
10920                                                         {
10921                                                           /* 33222222222211111111110000000000
10922                                                              10987654321098765432109876543210
10923                                                              000001x1xx1xxxxx011000xxxxxxxxxx
10924                                                              zip1.  */
10925                                                           return 2045;
10926                                                         }
10927                                                     }
10928                                                   else
10929                                                     {
10930                                                       if (((word >> 13) & 0x1) == 0)
10931                                                         {
10932                                                           /* 33222222222211111111110000000000
10933                                                              10987654321098765432109876543210
10934                                                              000001x1xx1xxxxx010100xxxxxxxxxx
10935                                                              trn1.  */
10936                                                           return 1969;
10937                                                         }
10938                                                       else
10939                                                         {
10940                                                           /* 33222222222211111111110000000000
10941                                                              10987654321098765432109876543210
10942                                                              000001x1xx1xxxxx011100xxxxxxxxxx
10943                                                              trn1.  */
10944                                                           return 1970;
10945                                                         }
10946                                                     }
10947                                                 }
10948                                               else
10949                                                 {
10950                                                   if (((word >> 13) & 0x1) == 0)
10951                                                     {
10952                                                       /* 33222222222211111111110000000000
10953                                                          10987654321098765432109876543210
10954                                                          000001x1xx1xxxxx010x10xxxxxxxxxx
10955                                                          uzp1.  */
10956                                                       return 2031;
10957                                                     }
10958                                                   else
10959                                                     {
10960                                                       /* 33222222222211111111110000000000
10961                                                          10987654321098765432109876543210
10962                                                          000001x1xx1xxxxx011x10xxxxxxxxxx
10963                                                          uzp1.  */
10964                                                       return 2032;
10965                                                     }
10966                                                 }
10967                                             }
10968                                           else
10969                                             {
10970                                               if (((word >> 11) & 0x1) == 0)
10971                                                 {
10972                                                   if (((word >> 12) & 0x1) == 0)
10973                                                     {
10974                                                       if (((word >> 13) & 0x1) == 0)
10975                                                         {
10976                                                           /* 33222222222211111111110000000000
10977                                                              10987654321098765432109876543210
10978                                                              000001x1xx1xxxxx010001xxxxxxxxxx
10979                                                              zip2.  */
10980                                                           return 2046;
10981                                                         }
10982                                                       else
10983                                                         {
10984                                                           /* 33222222222211111111110000000000
10985                                                              10987654321098765432109876543210
10986                                                              000001x1xx1xxxxx011001xxxxxxxxxx
10987                                                              zip2.  */
10988                                                           return 2047;
10989                                                         }
10990                                                     }
10991                                                   else
10992                                                     {
10993                                                       if (((word >> 13) & 0x1) == 0)
10994                                                         {
10995                                                           /* 33222222222211111111110000000000
10996                                                              10987654321098765432109876543210
10997                                                              000001x1xx1xxxxx010101xxxxxxxxxx
10998                                                              trn2.  */
10999                                                           return 1971;
11000                                                         }
11001                                                       else
11002                                                         {
11003                                                           /* 33222222222211111111110000000000
11004                                                              10987654321098765432109876543210
11005                                                              000001x1xx1xxxxx011101xxxxxxxxxx
11006                                                              trn2.  */
11007                                                           return 1972;
11008                                                         }
11009                                                     }
11010                                                 }
11011                                               else
11012                                                 {
11013                                                   if (((word >> 13) & 0x1) == 0)
11014                                                     {
11015                                                       /* 33222222222211111111110000000000
11016                                                          10987654321098765432109876543210
11017                                                          000001x1xx1xxxxx010x11xxxxxxxxxx
11018                                                          uzp2.  */
11019                                                       return 2033;
11020                                                     }
11021                                                   else
11022                                                     {
11023                                                       /* 33222222222211111111110000000000
11024                                                          10987654321098765432109876543210
11025                                                          000001x1xx1xxxxx011x11xxxxxxxxxx
11026                                                          uzp2.  */
11027                                                       return 2034;
11028                                                     }
11029                                                 }
11030                                             }
11031                                         }
11032                                       else
11033                                         {
11034                                           /* 33222222222211111111110000000000
11035                                              10987654321098765432109876543210
11036                                              000001x1xx1xxxxx11xxxxxxxxxxxxxx
11037                                              sel.  */
11038                                           return 1835;
11039                                         }
11040                                     }
11041                                 }
11042                             }
11043                           else
11044                             {
11045                               if (((word >> 13) & 0x1) == 0)
11046                                 {
11047                                   if (((word >> 14) & 0x1) == 0)
11048                                     {
11049                                       if (((word >> 15) & 0x1) == 0)
11050                                         {
11051                                           if (((word >> 22) & 0x1) == 0)
11052                                             {
11053                                               /* 33222222222211111111110000000000
11054                                                  10987654321098765432109876543210
11055                                                  100001x1x0xxxxxx000xxxxxxxxxxxxx
11056                                                  ldr.  */
11057                                               return 1739;
11058                                             }
11059                                           else
11060                                             {
11061                                               /* 33222222222211111111110000000000
11062                                                  10987654321098765432109876543210
11063                                                  100001x1x1xxxxxx000xxxxxxxxxxxxx
11064                                                  prfb.  */
11065                                               return 1783;
11066                                             }
11067                                         }
11068                                       else
11069                                         {
11070                                           if (((word >> 23) & 0x1) == 0)
11071                                             {
11072                                               /* 33222222222211111111110000000000
11073                                                  10987654321098765432109876543210
11074                                                  100001x10xxxxxxx100xxxxxxxxxxxxx
11075                                                  ld1rsh.  */
11076                                               return 1568;
11077                                             }
11078                                           else
11079                                             {
11080                                               /* 33222222222211111111110000000000
11081                                                  10987654321098765432109876543210
11082                                                  100001x11xxxxxxx100xxxxxxxxxxxxx
11083                                                  ld1rsb.  */
11084                                               return 1565;
11085                                             }
11086                                         }
11087                                     }
11088                                   else
11089                                     {
11090                                       if (((word >> 15) & 0x1) == 0)
11091                                         {
11092                                           if (((word >> 23) & 0x1) == 0)
11093                                             {
11094                                               if (((word >> 21) & 0x1) == 0)
11095                                                 {
11096                                                   /* 33222222222211111111110000000000
11097                                                      10987654321098765432109876543210
11098                                                      100001x10x0xxxxx010xxxxxxxxxxxxx
11099                                                      ld1w.  */
11100                                                   return 1603;
11101                                                 }
11102                                               else
11103                                                 {
11104                                                   /* 33222222222211111111110000000000
11105                                                      10987654321098765432109876543210
11106                                                      100001x10x1xxxxx010xxxxxxxxxxxxx
11107                                                      ld1w.  */
11108                                                   return 1604;
11109                                                 }
11110                                             }
11111                                           else
11112                                             {
11113                                               if (((word >> 22) & 0x1) == 0)
11114                                                 {
11115                                                   /* 33222222222211111111110000000000
11116                                                      10987654321098765432109876543210
11117                                                      100001x110xxxxxx010xxxxxxxxxxxxx
11118                                                      ldr.  */
11119                                                   return 1740;
11120                                                 }
11121                                               else
11122                                                 {
11123                                                   /* 33222222222211111111110000000000
11124                                                      10987654321098765432109876543210
11125                                                      100001x111xxxxxx010xxxxxxxxxxxxx
11126                                                      prfw.  */
11127                                                   return 1804;
11128                                                 }
11129                                             }
11130                                         }
11131                                       else
11132                                         {
11133                                           if (((word >> 22) & 0x1) == 0)
11134                                             {
11135                                               if (((word >> 21) & 0x1) == 0)
11136                                                 {
11137                                                   if (((word >> 23) & 0x1) == 0)
11138                                                     {
11139                                                       /* 33222222222211111111110000000000
11140                                                          10987654321098765432109876543210
11141                                                          100001x1000xxxxx110xxxxxxxxxxxxx
11142                                                          prfw.  */
11143                                                       return 1800;
11144                                                     }
11145                                                   else
11146                                                     {
11147                                                       /* 33222222222211111111110000000000
11148                                                          10987654321098765432109876543210
11149                                                          100001x1100xxxxx110xxxxxxxxxxxxx
11150                                                          prfd.  */
11151                                                       return 1786;
11152                                                     }
11153                                                 }
11154                                               else
11155                                                 {
11156                                                   /* 33222222222211111111110000000000
11157                                                      10987654321098765432109876543210
11158                                                      100001x1x01xxxxx110xxxxxxxxxxxxx
11159                                                      ld1w.  */
11160                                                   return 1611;
11161                                                 }
11162                                             }
11163                                           else
11164                                             {
11165                                               if (((word >> 23) & 0x1) == 0)
11166                                                 {
11167                                                   /* 33222222222211111111110000000000
11168                                                      10987654321098765432109876543210
11169                                                      100001x101xxxxxx110xxxxxxxxxxxxx
11170                                                      ld1rw.  */
11171                                                   return 1571;
11172                                                 }
11173                                               else
11174                                                 {
11175                                                   /* 33222222222211111111110000000000
11176                                                      10987654321098765432109876543210
11177                                                      100001x111xxxxxx110xxxxxxxxxxxxx
11178                                                      ld1rsb.  */
11179                                                   return 1567;
11180                                                 }
11181                                             }
11182                                         }
11183                                     }
11184                                 }
11185                               else
11186                                 {
11187                                   if (((word >> 14) & 0x1) == 0)
11188                                     {
11189                                       if (((word >> 15) & 0x1) == 0)
11190                                         {
11191                                           /* 33222222222211111111110000000000
11192                                              10987654321098765432109876543210
11193                                              100001x1xxxxxxxx001xxxxxxxxxxxxx
11194                                              prfh.  */
11195                                           return 1797;
11196                                         }
11197                                       else
11198                                         {
11199                                           if (((word >> 22) & 0x1) == 0)
11200                                             {
11201                                               /* 33222222222211111111110000000000
11202                                                  10987654321098765432109876543210
11203                                                  100001x1x0xxxxxx101xxxxxxxxxxxxx
11204                                                  ldnt1w.  */
11205                                               return 2111;
11206                                             }
11207                                           else
11208                                             {
11209                                               if (((word >> 23) & 0x1) == 0)
11210                                                 {
11211                                                   /* 33222222222211111111110000000000
11212                                                      10987654321098765432109876543210
11213                                                      100001x101xxxxxx101xxxxxxxxxxxxx
11214                                                      ld1rsh.  */
11215                                                   return 1569;
11216                                                 }
11217                                               else
11218                                                 {
11219                                                   /* 33222222222211111111110000000000
11220                                                      10987654321098765432109876543210
11221                                                      100001x111xxxxxx101xxxxxxxxxxxxx
11222                                                      ld1rsb.  */
11223                                                   return 1566;
11224                                                 }
11225                                             }
11226                                         }
11227                                     }
11228                                   else
11229                                     {
11230                                       if (((word >> 15) & 0x1) == 0)
11231                                         {
11232                                           if (((word >> 23) & 0x1) == 0)
11233                                             {
11234                                               if (((word >> 21) & 0x1) == 0)
11235                                                 {
11236                                                   /* 33222222222211111111110000000000
11237                                                      10987654321098765432109876543210
11238                                                      100001x10x0xxxxx011xxxxxxxxxxxxx
11239                                                      ldff1w.  */
11240                                                   return 1703;
11241                                                 }
11242                                               else
11243                                                 {
11244                                                   /* 33222222222211111111110000000000
11245                                                      10987654321098765432109876543210
11246                                                      100001x10x1xxxxx011xxxxxxxxxxxxx
11247                                                      ldff1w.  */
11248                                                   return 1704;
11249                                                 }
11250                                             }
11251                                           else
11252                                             {
11253                                               /* 33222222222211111111110000000000
11254                                                  10987654321098765432109876543210
11255                                                  100001x11xxxxxxx011xxxxxxxxxxxxx
11256                                                  prfd.  */
11257                                               return 1790;
11258                                             }
11259                                         }
11260                                       else
11261                                         {
11262                                           if (((word >> 22) & 0x1) == 0)
11263                                             {
11264                                               if (((word >> 21) & 0x1) == 0)
11265                                                 {
11266                                                   if (((word >> 23) & 0x1) == 0)
11267                                                     {
11268                                                       /* 33222222222211111111110000000000
11269                                                          10987654321098765432109876543210
11270                                                          100001x1000xxxxx111xxxxxxxxxxxxx
11271                                                          prfw.  */
11272                                                       return 1803;
11273                                                     }
11274                                                   else
11275                                                     {
11276                                                       /* 33222222222211111111110000000000
11277                                                          10987654321098765432109876543210
11278                                                          100001x1100xxxxx111xxxxxxxxxxxxx
11279                                                          prfd.  */
11280                                                       return 1789;
11281                                                     }
11282                                                 }
11283                                               else
11284                                                 {
11285                                                   /* 33222222222211111111110000000000
11286                                                      10987654321098765432109876543210
11287                                                      100001x1x01xxxxx111xxxxxxxxxxxxx
11288                                                      ldff1w.  */
11289                                                   return 1713;
11290                                                 }
11291                                             }
11292                                           else
11293                                             {
11294                                               if (((word >> 23) & 0x1) == 0)
11295                                                 {
11296                                                   /* 33222222222211111111110000000000
11297                                                      10987654321098765432109876543210
11298                                                      100001x101xxxxxx111xxxxxxxxxxxxx
11299                                                      ld1rw.  */
11300                                                   return 1572;
11301                                                 }
11302                                               else
11303                                                 {
11304                                                   /* 33222222222211111111110000000000
11305                                                      10987654321098765432109876543210
11306                                                      100001x111xxxxxx111xxxxxxxxxxxxx
11307                                                      ld1rd.  */
11308                                                   return 1553;
11309                                                 }
11310                                             }
11311                                         }
11312                                     }
11313                                 }
11314                             }
11315                         }
11316                       else
11317                         {
11318                           if (((word >> 13) & 0x1) == 0)
11319                             {
11320                               if (((word >> 14) & 0x1) == 0)
11321                                 {
11322                                   if (((word >> 15) & 0x1) == 0)
11323                                     {
11324                                       if (((word >> 21) & 0x1) == 0)
11325                                         {
11326                                           if (((word >> 31) & 0x1) == 0)
11327                                             {
11328                                               if (((word >> 10) & 0x1) == 0)
11329                                                 {
11330                                                   if (((word >> 11) & 0x1) == 0)
11331                                                     {
11332                                                       if (((word >> 12) & 0x1) == 0)
11333                                                         {
11334                                                           /* 33222222222211111111110000000000
11335                                                              10987654321098765432109876543210
11336                                                              010001x1xx0xxxxx000000xxxxxxxxxx
11337                                                              saddlb.  */
11338                                                           return 2141;
11339                                                         }
11340                                                       else
11341                                                         {
11342                                                           /* 33222222222211111111110000000000
11343                                                              10987654321098765432109876543210
11344                                                              010001x1xx0xxxxx000100xxxxxxxxxx
11345                                                              ssublb.  */
11346                                                           return 2248;
11347                                                         }
11348                                                     }
11349                                                   else
11350                                                     {
11351                                                       if (((word >> 12) & 0x1) == 0)
11352                                                         {
11353                                                           /* 33222222222211111111110000000000
11354                                                              10987654321098765432109876543210
11355                                                              010001x1xx0xxxxx000010xxxxxxxxxx
11356                                                              uaddlb.  */
11357                                                           return 2272;
11358                                                         }
11359                                                       else
11360                                                         {
11361                                                           /* 33222222222211111111110000000000
11362                                                              10987654321098765432109876543210
11363                                                              010001x1xx0xxxxx000110xxxxxxxxxx
11364                                                              usublb.  */
11365                                                           return 2325;
11366                                                         }
11367                                                     }
11368                                                 }
11369                                               else
11370                                                 {
11371                                                   if (((word >> 11) & 0x1) == 0)
11372                                                     {
11373                                                       if (((word >> 12) & 0x1) == 0)
11374                                                         {
11375                                                           /* 33222222222211111111110000000000
11376                                                              10987654321098765432109876543210
11377                                                              010001x1xx0xxxxx000001xxxxxxxxxx
11378                                                              saddlt.  */
11379                                                           return 2143;
11380                                                         }
11381                                                       else
11382                                                         {
11383                                                           /* 33222222222211111111110000000000
11384                                                              10987654321098765432109876543210
11385                                                              010001x1xx0xxxxx000101xxxxxxxxxx
11386                                                              ssublt.  */
11387                                                           return 2250;
11388                                                         }
11389                                                     }
11390                                                   else
11391                                                     {
11392                                                       if (((word >> 12) & 0x1) == 0)
11393                                                         {
11394                                                           /* 33222222222211111111110000000000
11395                                                              10987654321098765432109876543210
11396                                                              010001x1xx0xxxxx000011xxxxxxxxxx
11397                                                              uaddlt.  */
11398                                                           return 2273;
11399                                                         }
11400                                                       else
11401                                                         {
11402                                                           /* 33222222222211111111110000000000
11403                                                              10987654321098765432109876543210
11404                                                              010001x1xx0xxxxx000111xxxxxxxxxx
11405                                                              usublt.  */
11406                                                           return 2326;
11407                                                         }
11408                                                     }
11409                                                 }
11410                                             }
11411                                           else
11412                                             {
11413                                               /* 33222222222211111111110000000000
11414                                                  10987654321098765432109876543210
11415                                                  110001x1xx0xxxxx000xxxxxxxxxxxxx
11416                                                  ld1sw.  */
11417                                               return 1597;
11418                                             }
11419                                         }
11420                                       else
11421                                         {
11422                                           if (((word >> 31) & 0x1) == 0)
11423                                             {
11424                                               if (((word >> 10) & 0x1) == 0)
11425                                                 {
11426                                                   if (((word >> 11) & 0x1) == 0)
11427                                                     {
11428                                                       if (((word >> 12) & 0x1) == 0)
11429                                                         {
11430                                                           /* 33222222222211111111110000000000
11431                                                              10987654321098765432109876543210
11432                                                              010001x1xx1xxxxx000000xxxxxxxxxx
11433                                                              sqshrunb.  */
11434                                                           return 2231;
11435                                                         }
11436                                                       else
11437                                                         {
11438                                                           /* 33222222222211111111110000000000
11439                                                              10987654321098765432109876543210
11440                                                              010001x1xx1xxxxx000100xxxxxxxxxx
11441                                                              shrnb.  */
11442                                                           return 2149;
11443                                                         }
11444                                                     }
11445                                                   else
11446                                                     {
11447                                                       if (((word >> 12) & 0x1) == 0)
11448                                                         {
11449                                                           /* 33222222222211111111110000000000
11450                                                              10987654321098765432109876543210
11451                                                              010001x1xx1xxxxx000010xxxxxxxxxx
11452                                                              sqrshrunb.  */
11453                                                           return 2223;
11454                                                         }
11455                                                       else
11456                                                         {
11457                                                           /* 33222222222211111111110000000000
11458                                                              10987654321098765432109876543210
11459                                                              010001x1xx1xxxxx000110xxxxxxxxxx
11460                                                              rshrnb.  */
11461                                                           return 2131;
11462                                                         }
11463                                                     }
11464                                                 }
11465                                               else
11466                                                 {
11467                                                   if (((word >> 11) & 0x1) == 0)
11468                                                     {
11469                                                       if (((word >> 12) & 0x1) == 0)
11470                                                         {
11471                                                           /* 33222222222211111111110000000000
11472                                                              10987654321098765432109876543210
11473                                                              010001x1xx1xxxxx000001xxxxxxxxxx
11474                                                              sqshrunt.  */
11475                                                           return 2232;
11476                                                         }
11477                                                       else
11478                                                         {
11479                                                           /* 33222222222211111111110000000000
11480                                                              10987654321098765432109876543210
11481                                                              010001x1xx1xxxxx000101xxxxxxxxxx
11482                                                              shrnt.  */
11483                                                           return 2150;
11484                                                         }
11485                                                     }
11486                                                   else
11487                                                     {
11488                                                       if (((word >> 12) & 0x1) == 0)
11489                                                         {
11490                                                           /* 33222222222211111111110000000000
11491                                                              10987654321098765432109876543210
11492                                                              010001x1xx1xxxxx000011xxxxxxxxxx
11493                                                              sqrshrunt.  */
11494                                                           return 2224;
11495                                                         }
11496                                                       else
11497                                                         {
11498                                                           /* 33222222222211111111110000000000
11499                                                              10987654321098765432109876543210
11500                                                              010001x1xx1xxxxx000111xxxxxxxxxx
11501                                                              rshrnt.  */
11502                                                           return 2132;
11503                                                         }
11504                                                     }
11505                                                 }
11506                                             }
11507                                           else
11508                                             {
11509                                               /* 33222222222211111111110000000000
11510                                                  10987654321098765432109876543210
11511                                                  110001x1xx1xxxxx000xxxxxxxxxxxxx
11512                                                  ld1sw.  */
11513                                               return 1598;
11514                                             }
11515                                         }
11516                                     }
11517                                   else
11518                                     {
11519                                       if (((word >> 21) & 0x1) == 0)
11520                                         {
11521                                           if (((word >> 31) & 0x1) == 0)
11522                                             {
11523                                               if (((word >> 10) & 0x1) == 0)
11524                                                 {
11525                                                   if (((word >> 11) & 0x1) == 0)
11526                                                     {
11527                                                       if (((word >> 12) & 0x1) == 0)
11528                                                         {
11529                                                           /* 33222222222211111111110000000000
11530                                                              10987654321098765432109876543210
11531                                                              010001x1xx0xxxxx100000xxxxxxxxxx
11532                                                              saddlbt.  */
11533                                                           return 2142;
11534                                                         }
11535                                                       else
11536                                                         {
11537                                                           /* 33222222222211111111110000000000
11538                                                              10987654321098765432109876543210
11539                                                              010001x1xx0xxxxx100100xxxxxxxxxx
11540                                                              eorbt.  */
11541                                                           return 2078;
11542                                                         }
11543                                                     }
11544                                                   else
11545                                                     {
11546                                                       if (((word >> 12) & 0x1) == 0)
11547                                                         {
11548                                                           /* 33222222222211111111110000000000
11549                                                              10987654321098765432109876543210
11550                                                              010001x1xx0xxxxx100010xxxxxxxxxx
11551                                                              ssublbt.  */
11552                                                           return 2249;
11553                                                         }
11554                                                       else
11555                                                         {
11556                                                           if (((word >> 22) & 0x1) == 0)
11557                                                             {
11558                                                               if (((word >> 23) & 0x1) == 0)
11559                                                                 {
11560                                                                   /* 33222222222211111111110000000000
11561                                                                      10987654321098765432109876543210
11562                                                                      010001x1000xxxxx100110xxxxxxxxxx
11563                                                                      smmla.  */
11564                                                                   return 2464;
11565                                                                 }
11566                                                               else
11567                                                                 {
11568                                                                   /* 33222222222211111111110000000000
11569                                                                      10987654321098765432109876543210
11570                                                                      010001x1100xxxxx100110xxxxxxxxxx
11571                                                                      usmmla.  */
11572                                                                   return 2466;
11573                                                                 }
11574                                                             }
11575                                                           else
11576                                                             {
11577                                                               /* 33222222222211111111110000000000
11578                                                                  10987654321098765432109876543210
11579                                                                  010001x1x10xxxxx100110xxxxxxxxxx
11580                                                                  ummla.  */
11581                                                               return 2465;
11582                                                             }
11583                                                         }
11584                                                     }
11585                                                 }
11586                                               else
11587                                                 {
11588                                                   if (((word >> 11) & 0x1) == 0)
11589                                                     {
11590                                                       /* 33222222222211111111110000000000
11591                                                          10987654321098765432109876543210
11592                                                          010001x1xx0xxxxx100x01xxxxxxxxxx
11593                                                          eortb.  */
11594                                                       return 2079;
11595                                                     }
11596                                                   else
11597                                                     {
11598                                                       /* 33222222222211111111110000000000
11599                                                          10987654321098765432109876543210
11600                                                          010001x1xx0xxxxx100x11xxxxxxxxxx
11601                                                          ssubltb.  */
11602                                                       return 2251;
11603                                                     }
11604                                                 }
11605                                             }
11606                                           else
11607                                             {
11608                                               if (((word >> 22) & 0x1) == 0)
11609                                                 {
11610                                                   /* 33222222222211111111110000000000
11611                                                      10987654321098765432109876543210
11612                                                      110001x1x00xxxxx100xxxxxxxxxxxxx
11613                                                      ldnt1sw.  */
11614                                                   return 2110;
11615                                                 }
11616                                               else
11617                                                 {
11618                                                   /* 33222222222211111111110000000000
11619                                                      10987654321098765432109876543210
11620                                                      110001x1x10xxxxx100xxxxxxxxxxxxx
11621                                                      ld1sw.  */
11622                                                   return 1599;
11623                                                 }
11624                                             }
11625                                         }
11626                                       else
11627                                         {
11628                                           if (((word >> 31) & 0x1) == 0)
11629                                             {
11630                                               if (((word >> 4) & 0x1) == 0)
11631                                                 {
11632                                                   /* 33222222222211111111110000000000
11633                                                      10987654321098765432109876543210
11634                                                      010001x1xx1xxxxx100xxxxxxxx0xxxx
11635                                                      match.  */
11636                                                   return 2113;
11637                                                 }
11638                                               else
11639                                                 {
11640                                                   /* 33222222222211111111110000000000
11641                                                      10987654321098765432109876543210
11642                                                      010001x1xx1xxxxx100xxxxxxxx1xxxx
11643                                                      nmatch.  */
11644                                                   return 2125;
11645                                                 }
11646                                             }
11647                                           else
11648                                             {
11649                                               if (((word >> 22) & 0x1) == 0)
11650                                                 {
11651                                                   /* 33222222222211111111110000000000
11652                                                      10987654321098765432109876543210
11653                                                      110001x1x01xxxxx100xxxxxxxxxxxxx
11654                                                      ld1sw.  */
11655                                                   return 1602;
11656                                                 }
11657                                               else
11658                                                 {
11659                                                   /* 33222222222211111111110000000000
11660                                                      10987654321098765432109876543210
11661                                                      110001x1x11xxxxx100xxxxxxxxxxxxx
11662                                                      ld1sw.  */
11663                                                   return 1600;
11664                                                 }
11665                                             }
11666                                         }
11667                                     }
11668                                 }
11669                               else
11670                                 {
11671                                   if (((word >> 15) & 0x1) == 0)
11672                                     {
11673                                       if (((word >> 21) & 0x1) == 0)
11674                                         {
11675                                           if (((word >> 31) & 0x1) == 0)
11676                                             {
11677                                               if (((word >> 10) & 0x1) == 0)
11678                                                 {
11679                                                   if (((word >> 11) & 0x1) == 0)
11680                                                     {
11681                                                       if (((word >> 12) & 0x1) == 0)
11682                                                         {
11683                                                           /* 33222222222211111111110000000000
11684                                                              10987654321098765432109876543210
11685                                                              010001x1xx0xxxxx010000xxxxxxxxxx
11686                                                              saddwb.  */
11687                                                           return 2144;
11688                                                         }
11689                                                       else
11690                                                         {
11691                                                           /* 33222222222211111111110000000000
11692                                                              10987654321098765432109876543210
11693                                                              010001x1xx0xxxxx010100xxxxxxxxxx
11694                                                              ssubwb.  */
11695                                                           return 2252;
11696                                                         }
11697                                                     }
11698                                                   else
11699                                                     {
11700                                                       if (((word >> 12) & 0x1) == 0)
11701                                                         {
11702                                                           /* 33222222222211111111110000000000
11703                                                              10987654321098765432109876543210
11704                                                              010001x1xx0xxxxx010010xxxxxxxxxx
11705                                                              uaddwb.  */
11706                                                           return 2274;
11707                                                         }
11708                                                       else
11709                                                         {
11710                                                           /* 33222222222211111111110000000000
11711                                                              10987654321098765432109876543210
11712                                                              010001x1xx0xxxxx010110xxxxxxxxxx
11713                                                              usubwb.  */
11714                                                           return 2327;
11715                                                         }
11716                                                     }
11717                                                 }
11718                                               else
11719                                                 {
11720                                                   if (((word >> 11) & 0x1) == 0)
11721                                                     {
11722                                                       if (((word >> 12) & 0x1) == 0)
11723                                                         {
11724                                                           /* 33222222222211111111110000000000
11725                                                              10987654321098765432109876543210
11726                                                              010001x1xx0xxxxx010001xxxxxxxxxx
11727                                                              saddwt.  */
11728                                                           return 2145;
11729                                                         }
11730                                                       else
11731                                                         {
11732                                                           /* 33222222222211111111110000000000
11733                                                              10987654321098765432109876543210
11734                                                              010001x1xx0xxxxx010101xxxxxxxxxx
11735                                                              ssubwt.  */
11736                                                           return 2253;
11737                                                         }
11738                                                     }
11739                                                   else
11740                                                     {
11741                                                       if (((word >> 12) & 0x1) == 0)
11742                                                         {
11743                                                           /* 33222222222211111111110000000000
11744                                                              10987654321098765432109876543210
11745                                                              010001x1xx0xxxxx010011xxxxxxxxxx
11746                                                              uaddwt.  */
11747                                                           return 2275;
11748                                                         }
11749                                                       else
11750                                                         {
11751                                                           /* 33222222222211111111110000000000
11752                                                              10987654321098765432109876543210
11753                                                              010001x1xx0xxxxx010111xxxxxxxxxx
11754                                                              usubwt.  */
11755                                                           return 2328;
11756                                                         }
11757                                                     }
11758                                                 }
11759                                             }
11760                                           else
11761                                             {
11762                                               if (((word >> 23) & 0x1) == 0)
11763                                                 {
11764                                                   /* 33222222222211111111110000000000
11765                                                      10987654321098765432109876543210
11766                                                      110001x10x0xxxxx010xxxxxxxxxxxxx
11767                                                      ld1w.  */
11768                                                   return 1607;
11769                                                 }
11770                                               else
11771                                                 {
11772                                                   /* 33222222222211111111110000000000
11773                                                      10987654321098765432109876543210
11774                                                      110001x11x0xxxxx010xxxxxxxxxxxxx
11775                                                      ld1d.  */
11776                                                   return 1529;
11777                                                 }
11778                                             }
11779                                         }
11780                                       else
11781                                         {
11782                                           if (((word >> 23) & 0x1) == 0)
11783                                             {
11784                                               if (((word >> 31) & 0x1) == 0)
11785                                                 {
11786                                                   if (((word >> 10) & 0x1) == 0)
11787                                                     {
11788                                                       if (((word >> 11) & 0x1) == 0)
11789                                                         {
11790                                                           if (((word >> 12) & 0x1) == 0)
11791                                                             {
11792                                                               /* 33222222222211111111110000000000
11793                                                                  10987654321098765432109876543210
11794                                                                  010001x10x1xxxxx010000xxxxxxxxxx
11795                                                                  sqxtnb.  */
11796                                                               return 2235;
11797                                                             }
11798                                                           else
11799                                                             {
11800                                                               /* 33222222222211111111110000000000
11801                                                                  10987654321098765432109876543210
11802                                                                  010001x10x1xxxxx010100xxxxxxxxxx
11803                                                                  sqxtunb.  */
11804                                                               return 2237;
11805                                                             }
11806                                                         }
11807                                                       else
11808                                                         {
11809                                                           /* 33222222222211111111110000000000
11810                                                              10987654321098765432109876543210
11811                                                              010001x10x1xxxxx010x10xxxxxxxxxx
11812                                                              uqxtnb.  */
11813                                                           return 2312;
11814                                                         }
11815                                                     }
11816                                                   else
11817                                                     {
11818                                                       if (((word >> 11) & 0x1) == 0)
11819                                                         {
11820                                                           if (((word >> 12) & 0x1) == 0)
11821                                                             {
11822                                                               /* 33222222222211111111110000000000
11823                                                                  10987654321098765432109876543210
11824                                                                  010001x10x1xxxxx010001xxxxxxxxxx
11825                                                                  sqxtnt.  */
11826                                                               return 2236;
11827                                                             }
11828                                                           else
11829                                                             {
11830                                                               /* 33222222222211111111110000000000
11831                                                                  10987654321098765432109876543210
11832                                                                  010001x10x1xxxxx010101xxxxxxxxxx
11833                                                                  sqxtunt.  */
11834                                                               return 2238;
11835                                                             }
11836                                                         }
11837                                                       else
11838                                                         {
11839                                                           /* 33222222222211111111110000000000
11840                                                              10987654321098765432109876543210
11841                                                              010001x10x1xxxxx010x11xxxxxxxxxx
11842                                                              uqxtnt.  */
11843                                                           return 2313;
11844                                                         }
11845                                                     }
11846                                                 }
11847                                               else
11848                                                 {
11849                                                   /* 33222222222211111111110000000000
11850                                                      10987654321098765432109876543210
11851                                                      110001x10x1xxxxx010xxxxxxxxxxxxx
11852                                                      ld1w.  */
11853                                                   return 1608;
11854                                                 }
11855                                             }
11856                                           else
11857                                             {
11858                                               /* 33222222222211111111110000000000
11859                                                  10987654321098765432109876543210
11860                                                  x10001x11x1xxxxx010xxxxxxxxxxxxx
11861                                                  ld1d.  */
11862                                               return 1530;
11863                                             }
11864                                         }
11865                                     }
11866                                   else
11867                                     {
11868                                       if (((word >> 21) & 0x1) == 0)
11869                                         {
11870                                           if (((word >> 31) & 0x1) == 0)
11871                                             {
11872                                               if (((word >> 11) & 0x1) == 0)
11873                                                 {
11874                                                   if (((word >> 10) & 0x1) == 0)
11875                                                     {
11876                                                       if (((word >> 12) & 0x1) == 0)
11877                                                         {
11878                                                           /* 33222222222211111111110000000000
11879                                                              10987654321098765432109876543210
11880                                                              010001x1xx0xxxxx110000xxxxxxxxxx
11881                                                              sabalb.  */
11882                                                           return 2136;
11883                                                         }
11884                                                       else
11885                                                         {
11886                                                           if (((word >> 23) & 0x1) == 0)
11887                                                             {
11888                                                               /* 33222222222211111111110000000000
11889                                                                  10987654321098765432109876543210
11890                                                                  010001x10x0xxxxx110100xxxxxxxxxx
11891                                                                  adclb.  */
11892                                                               return 2061;
11893                                                             }
11894                                                           else
11895                                                             {
11896                                                               /* 33222222222211111111110000000000
11897                                                                  10987654321098765432109876543210
11898                                                                  010001x11x0xxxxx110100xxxxxxxxxx
11899                                                                  sbclb.  */
11900                                                               return 2146;
11901                                                             }
11902                                                         }
11903                                                     }
11904                                                   else
11905                                                     {
11906                                                       if (((word >> 12) & 0x1) == 0)
11907                                                         {
11908                                                           /* 33222222222211111111110000000000
11909                                                              10987654321098765432109876543210
11910                                                              010001x1xx0xxxxx110001xxxxxxxxxx
11911                                                              sabalt.  */
11912                                                           return 2137;
11913                                                         }
11914                                                       else
11915                                                         {
11916                                                           if (((word >> 23) & 0x1) == 0)
11917                                                             {
11918                                                               /* 33222222222211111111110000000000
11919                                                                  10987654321098765432109876543210
11920                                                                  010001x10x0xxxxx110101xxxxxxxxxx
11921                                                                  adclt.  */
11922                                                               return 2062;
11923                                                             }
11924                                                           else
11925                                                             {
11926                                                               /* 33222222222211111111110000000000
11927                                                                  10987654321098765432109876543210
11928                                                                  010001x11x0xxxxx110101xxxxxxxxxx
11929                                                                  sbclt.  */
11930                                                               return 2147;
11931                                                             }
11932                                                         }
11933                                                     }
11934                                                 }
11935                                               else
11936                                                 {
11937                                                   if (((word >> 12) & 0x1) == 0)
11938                                                     {
11939                                                       if (((word >> 10) & 0x1) == 0)
11940                                                         {
11941                                                           /* 33222222222211111111110000000000
11942                                                              10987654321098765432109876543210
11943                                                              010001x1xx0xxxxx110010xxxxxxxxxx
11944                                                              uabalb.  */
11945                                                           return 2267;
11946                                                         }
11947                                                       else
11948                                                         {
11949                                                           /* 33222222222211111111110000000000
11950                                                              10987654321098765432109876543210
11951                                                              010001x1xx0xxxxx110011xxxxxxxxxx
11952                                                              uabalt.  */
11953                                                           return 2268;
11954                                                         }
11955                                                     }
11956                                                   else
11957                                                     {
11958                                                       if (((word >> 16) & 0x1) == 0)
11959                                                         {
11960                                                           /* 33222222222211111111110000000000
11961                                                              10987654321098765432109876543210
11962                                                              010001x1xx0xxxx011011xxxxxxxxxxx
11963                                                              cadd.  */
11964                                                           return 2070;
11965                                                         }
11966                                                       else
11967                                                         {
11968                                                           /* 33222222222211111111110000000000
11969                                                              10987654321098765432109876543210
11970                                                              010001x1xx0xxxx111011xxxxxxxxxxx
11971                                                              sqcadd.  */
11972                                                           return 2178;
11973                                                         }
11974                                                     }
11975                                                 }
11976                                             }
11977                                           else
11978                                             {
11979                                               if (((word >> 22) & 0x1) == 0)
11980                                                 {
11981                                                   if (((word >> 23) & 0x1) == 0)
11982                                                     {
11983                                                       /* 33222222222211111111110000000000
11984                                                          10987654321098765432109876543210
11985                                                          110001x1000xxxxx110xxxxxxxxxxxxx
11986                                                          ldnt1w.  */
11987                                                       return 2112;
11988                                                     }
11989                                                   else
11990                                                     {
11991                                                       /* 33222222222211111111110000000000
11992                                                          10987654321098765432109876543210
11993                                                          110001x1100xxxxx110xxxxxxxxxxxxx
11994                                                          ldnt1d.  */
11995                                                       return 2105;
11996                                                     }
11997                                                 }
11998                                               else
11999                                                 {
12000                                                   if (((word >> 23) & 0x1) == 0)
12001                                                     {
12002                                                       /* 33222222222211111111110000000000
12003                                                          10987654321098765432109876543210
12004                                                          110001x1010xxxxx110xxxxxxxxxxxxx
12005                                                          ld1w.  */
12006                                                       return 1609;
12007                                                     }
12008                                                   else
12009                                                     {
12010                                                       /* 33222222222211111111110000000000
12011                                                          10987654321098765432109876543210
12012                                                          110001x1110xxxxx110xxxxxxxxxxxxx
12013                                                          ld1d.  */
12014                                                       return 1531;
12015                                                     }
12016                                                 }
12017                                             }
12018                                         }
12019                                       else
12020                                         {
12021                                           if (((word >> 23) & 0x1) == 0)
12022                                             {
12023                                               if (((word >> 22) & 0x1) == 0)
12024                                                 {
12025                                                   /* 33222222222211111111110000000000
12026                                                      10987654321098765432109876543210
12027                                                      x10001x1001xxxxx110xxxxxxxxxxxxx
12028                                                      ld1w.  */
12029                                                   return 1614;
12030                                                 }
12031                                               else
12032                                                 {
12033                                                   /* 33222222222211111111110000000000
12034                                                      10987654321098765432109876543210
12035                                                      x10001x1011xxxxx110xxxxxxxxxxxxx
12036                                                      ld1w.  */
12037                                                   return 1610;
12038                                                 }
12039                                             }
12040                                           else
12041                                             {
12042                                               if (((word >> 31) & 0x1) == 0)
12043                                                 {
12044                                                   /* 33222222222211111111110000000000
12045                                                      10987654321098765432109876543210
12046                                                      010001x11x1xxxxx110xxxxxxxxxxxxx
12047                                                      histcnt.  */
12048                                                   return 2101;
12049                                                 }
12050                                               else
12051                                                 {
12052                                                   if (((word >> 22) & 0x1) == 0)
12053                                                     {
12054                                                       /* 33222222222211111111110000000000
12055                                                          10987654321098765432109876543210
12056                                                          110001x1101xxxxx110xxxxxxxxxxxxx
12057                                                          ld1d.  */
12058                                                       return 1534;
12059                                                     }
12060                                                   else
12061                                                     {
12062                                                       /* 33222222222211111111110000000000
12063                                                          10987654321098765432109876543210
12064                                                          110001x1111xxxxx110xxxxxxxxxxxxx
12065                                                          ld1d.  */
12066                                                       return 1532;
12067                                                     }
12068                                                 }
12069                                             }
12070                                         }
12071                                     }
12072                                 }
12073                             }
12074                           else
12075                             {
12076                               if (((word >> 14) & 0x1) == 0)
12077                                 {
12078                                   if (((word >> 15) & 0x1) == 0)
12079                                     {
12080                                       if (((word >> 21) & 0x1) == 0)
12081                                         {
12082                                           if (((word >> 31) & 0x1) == 0)
12083                                             {
12084                                               if (((word >> 10) & 0x1) == 0)
12085                                                 {
12086                                                   if (((word >> 11) & 0x1) == 0)
12087                                                     {
12088                                                       /* 33222222222211111111110000000000
12089                                                          10987654321098765432109876543210
12090                                                          010001x1xx0xxxxx001x00xxxxxxxxxx
12091                                                          sabdlb.  */
12092                                                       return 2138;
12093                                                     }
12094                                                   else
12095                                                     {
12096                                                       /* 33222222222211111111110000000000
12097                                                          10987654321098765432109876543210
12098                                                          010001x1xx0xxxxx001x10xxxxxxxxxx
12099                                                          uabdlb.  */
12100                                                       return 2269;
12101                                                     }
12102                                                 }
12103                                               else
12104                                                 {
12105                                                   if (((word >> 11) & 0x1) == 0)
12106                                                     {
12107                                                       /* 33222222222211111111110000000000
12108                                                          10987654321098765432109876543210
12109                                                          010001x1xx0xxxxx001x01xxxxxxxxxx
12110                                                          sabdlt.  */
12111                                                       return 2139;
12112                                                     }
12113                                                   else
12114                                                     {
12115                                                       /* 33222222222211111111110000000000
12116                                                          10987654321098765432109876543210
12117                                                          010001x1xx0xxxxx001x11xxxxxxxxxx
12118                                                          uabdlt.  */
12119                                                       return 2270;
12120                                                     }
12121                                                 }
12122                                             }
12123                                           else
12124                                             {
12125                                               /* 33222222222211111111110000000000
12126                                                  10987654321098765432109876543210
12127                                                  110001x1xx0xxxxx001xxxxxxxxxxxxx
12128                                                  ldff1sw.  */
12129                                               return 1698;
12130                                             }
12131                                         }
12132                                       else
12133                                         {
12134                                           if (((word >> 31) & 0x1) == 0)
12135                                             {
12136                                               if (((word >> 10) & 0x1) == 0)
12137                                                 {
12138                                                   if (((word >> 11) & 0x1) == 0)
12139                                                     {
12140                                                       if (((word >> 12) & 0x1) == 0)
12141                                                         {
12142                                                           /* 33222222222211111111110000000000
12143                                                              10987654321098765432109876543210
12144                                                              010001x1xx1xxxxx001000xxxxxxxxxx
12145                                                              sqshrnb.  */
12146                                                           return 2229;
12147                                                         }
12148                                                       else
12149                                                         {
12150                                                           /* 33222222222211111111110000000000
12151                                                              10987654321098765432109876543210
12152                                                              010001x1xx1xxxxx001100xxxxxxxxxx
12153                                                              uqshrnb.  */
12154                                                           return 2308;
12155                                                         }
12156                                                     }
12157                                                   else
12158                                                     {
12159                                                       if (((word >> 12) & 0x1) == 0)
12160                                                         {
12161                                                           /* 33222222222211111111110000000000
12162                                                              10987654321098765432109876543210
12163                                                              010001x1xx1xxxxx001010xxxxxxxxxx
12164                                                              sqrshrnb.  */
12165                                                           return 2221;
12166                                                         }
12167                                                       else
12168                                                         {
12169                                                           /* 33222222222211111111110000000000
12170                                                              10987654321098765432109876543210
12171                                                              010001x1xx1xxxxx001110xxxxxxxxxx
12172                                                              uqrshrnb.  */
12173                                                           return 2303;
12174                                                         }
12175                                                     }
12176                                                 }
12177                                               else
12178                                                 {
12179                                                   if (((word >> 11) & 0x1) == 0)
12180                                                     {
12181                                                       if (((word >> 12) & 0x1) == 0)
12182                                                         {
12183                                                           /* 33222222222211111111110000000000
12184                                                              10987654321098765432109876543210
12185                                                              010001x1xx1xxxxx001001xxxxxxxxxx
12186                                                              sqshrnt.  */
12187                                                           return 2230;
12188                                                         }
12189                                                       else
12190                                                         {
12191                                                           /* 33222222222211111111110000000000
12192                                                              10987654321098765432109876543210
12193                                                              010001x1xx1xxxxx001101xxxxxxxxxx
12194                                                              uqshrnt.  */
12195                                                           return 2309;
12196                                                         }
12197                                                     }
12198                                                   else
12199                                                     {
12200                                                       if (((word >> 12) & 0x1) == 0)
12201                                                         {
12202                                                           /* 33222222222211111111110000000000
12203                                                              10987654321098765432109876543210
12204                                                              010001x1xx1xxxxx001011xxxxxxxxxx
12205                                                              sqrshrnt.  */
12206                                                           return 2222;
12207                                                         }
12208                                                       else
12209                                                         {
12210                                                           /* 33222222222211111111110000000000
12211                                                              10987654321098765432109876543210
12212                                                              010001x1xx1xxxxx001111xxxxxxxxxx
12213                                                              uqrshrnt.  */
12214                                                           return 2304;
12215                                                         }
12216                                                     }
12217                                                 }
12218                                             }
12219                                           else
12220                                             {
12221                                               /* 33222222222211111111110000000000
12222                                                  10987654321098765432109876543210
12223                                                  110001x1xx1xxxxx001xxxxxxxxxxxxx
12224                                                  ldff1sw.  */
12225                                               return 1699;
12226                                             }
12227                                         }
12228                                     }
12229                                   else
12230                                     {
12231                                       if (((word >> 21) & 0x1) == 0)
12232                                         {
12233                                           if (((word >> 31) & 0x1) == 0)
12234                                             {
12235                                               if (((word >> 10) & 0x1) == 0)
12236                                                 {
12237                                                   if (((word >> 11) & 0x1) == 0)
12238                                                     {
12239                                                       if (((word >> 12) & 0x1) == 0)
12240                                                         {
12241                                                           /* 33222222222211111111110000000000
12242                                                              10987654321098765432109876543210
12243                                                              010001x1xx0xxxxx101000xxxxxxxxxx
12244                                                              sshllb.  */
12245                                                           return 2245;
12246                                                         }
12247                                                       else
12248                                                         {
12249                                                           /* 33222222222211111111110000000000
12250                                                              10987654321098765432109876543210
12251                                                              010001x1xx0xxxxx101100xxxxxxxxxx
12252                                                              bext.  */
12253                                                           return 2350;
12254                                                         }
12255                                                     }
12256                                                   else
12257                                                     {
12258                                                       if (((word >> 12) & 0x1) == 0)
12259                                                         {
12260                                                           /* 33222222222211111111110000000000
12261                                                              10987654321098765432109876543210
12262                                                              010001x1xx0xxxxx101010xxxxxxxxxx
12263                                                              ushllb.  */
12264                                                           return 2321;
12265                                                         }
12266                                                       else
12267                                                         {
12268                                                           /* 33222222222211111111110000000000
12269                                                              10987654321098765432109876543210
12270                                                              010001x1xx0xxxxx101110xxxxxxxxxx
12271                                                              bgrp.  */
12272                                                           return 2351;
12273                                                         }
12274                                                     }
12275                                                 }
12276                                               else
12277                                                 {
12278                                                   if (((word >> 11) & 0x1) == 0)
12279                                                     {
12280                                                       if (((word >> 12) & 0x1) == 0)
12281                                                         {
12282                                                           /* 33222222222211111111110000000000
12283                                                              10987654321098765432109876543210
12284                                                              010001x1xx0xxxxx101001xxxxxxxxxx
12285                                                              sshllt.  */
12286                                                           return 2246;
12287                                                         }
12288                                                       else
12289                                                         {
12290                                                           /* 33222222222211111111110000000000
12291                                                              10987654321098765432109876543210
12292                                                              010001x1xx0xxxxx101101xxxxxxxxxx
12293                                                              bdep.  */
12294                                                           return 2349;
12295                                                         }
12296                                                     }
12297                                                   else
12298                                                     {
12299                                                       /* 33222222222211111111110000000000
12300                                                          10987654321098765432109876543210
12301                                                          010001x1xx0xxxxx101x11xxxxxxxxxx
12302                                                          ushllt.  */
12303                                                       return 2322;
12304                                                     }
12305                                                 }
12306                                             }
12307                                           else
12308                                             {
12309                                               /* 33222222222211111111110000000000
12310                                                  10987654321098765432109876543210
12311                                                  110001x1xx0xxxxx101xxxxxxxxxxxxx
12312                                                  ldff1sw.  */
12313                                               return 1700;
12314                                             }
12315                                         }
12316                                       else
12317                                         {
12318                                           if (((word >> 22) & 0x1) == 0)
12319                                             {
12320                                               if (((word >> 31) & 0x1) == 0)
12321                                                 {
12322                                                   /* 33222222222211111111110000000000
12323                                                      10987654321098765432109876543210
12324                                                      010001x1x01xxxxx101xxxxxxxxxxxxx
12325                                                      histseg.  */
12326                                                   return 2102;
12327                                                 }
12328                                               else
12329                                                 {
12330                                                   /* 33222222222211111111110000000000
12331                                                      10987654321098765432109876543210
12332                                                      110001x1x01xxxxx101xxxxxxxxxxxxx
12333                                                      ldff1sw.  */
12334                                                   return 1702;
12335                                                 }
12336                                             }
12337                                           else
12338                                             {
12339                                               /* 33222222222211111111110000000000
12340                                                  10987654321098765432109876543210
12341                                                  x10001x1x11xxxxx101xxxxxxxxxxxxx
12342                                                  ldff1sw.  */
12343                                               return 1701;
12344                                             }
12345                                         }
12346                                     }
12347                                 }
12348                               else
12349                                 {
12350                                   if (((word >> 15) & 0x1) == 0)
12351                                     {
12352                                       if (((word >> 21) & 0x1) == 0)
12353                                         {
12354                                           if (((word >> 31) & 0x1) == 0)
12355                                             {
12356                                               if (((word >> 10) & 0x1) == 0)
12357                                                 {
12358                                                   if (((word >> 11) & 0x1) == 0)
12359                                                     {
12360                                                       if (((word >> 12) & 0x1) == 0)
12361                                                         {
12362                                                           /* 33222222222211111111110000000000
12363                                                              10987654321098765432109876543210
12364                                                              010001x1xx0xxxxx011000xxxxxxxxxx
12365                                                              sqdmullb.  */
12366                                                           return 2199;
12367                                                         }
12368                                                       else
12369                                                         {
12370                                                           /* 33222222222211111111110000000000
12371                                                              10987654321098765432109876543210
12372                                                              010001x1xx0xxxxx011100xxxxxxxxxx
12373                                                              smullb.  */
12374                                                           return 2171;
12375                                                         }
12376                                                     }
12377                                                   else
12378                                                     {
12379                                                       if (((word >> 12) & 0x1) == 0)
12380                                                         {
12381                                                           if (((word >> 22) & 0x1) == 0)
12382                                                             {
12383                                                               /* 33222222222211111111110000000000
12384                                                                  10987654321098765432109876543210
12385                                                                  010001x1x00xxxxx011010xxxxxxxxxx
12386                                                                  pmullb.  */
12387                                                               return 2346;
12388                                                             }
12389                                                           else
12390                                                             {
12391                                                               /* 33222222222211111111110000000000
12392                                                                  10987654321098765432109876543210
12393                                                                  010001x1x10xxxxx011010xxxxxxxxxx
12394                                                                  pmullb.  */
12395                                                               return 2127;
12396                                                             }
12397                                                         }
12398                                                       else
12399                                                         {
12400                                                           /* 33222222222211111111110000000000
12401                                                              10987654321098765432109876543210
12402                                                              010001x1xx0xxxxx011110xxxxxxxxxx
12403                                                              umullb.  */
12404                                                           return 2296;
12405                                                         }
12406                                                     }
12407                                                 }
12408                                               else
12409                                                 {
12410                                                   if (((word >> 11) & 0x1) == 0)
12411                                                     {
12412                                                       if (((word >> 12) & 0x1) == 0)
12413                                                         {
12414                                                           /* 33222222222211111111110000000000
12415                                                              10987654321098765432109876543210
12416                                                              010001x1xx0xxxxx011001xxxxxxxxxx
12417                                                              sqdmullt.  */
12418                                                           return 2202;
12419                                                         }
12420                                                       else
12421                                                         {
12422                                                           /* 33222222222211111111110000000000
12423                                                              10987654321098765432109876543210
12424                                                              010001x1xx0xxxxx011101xxxxxxxxxx
12425                                                              smullt.  */
12426                                                           return 2174;
12427                                                         }
12428                                                     }
12429                                                   else
12430                                                     {
12431                                                       if (((word >> 12) & 0x1) == 0)
12432                                                         {
12433                                                           if (((word >> 22) & 0x1) == 0)
12434                                                             {
12435                                                               /* 33222222222211111111110000000000
12436                                                                  10987654321098765432109876543210
12437                                                                  010001x1x00xxxxx011011xxxxxxxxxx
12438                                                                  pmullt.  */
12439                                                               return 2347;
12440                                                             }
12441                                                           else
12442                                                             {
12443                                                               /* 33222222222211111111110000000000
12444                                                                  10987654321098765432109876543210
12445                                                                  010001x1x10xxxxx011011xxxxxxxxxx
12446                                                                  pmullt.  */
12447                                                               return 2128;
12448                                                             }
12449                                                         }
12450                                                       else
12451                                                         {
12452                                                           /* 33222222222211111111110000000000
12453                                                              10987654321098765432109876543210
12454                                                              010001x1xx0xxxxx011111xxxxxxxxxx
12455                                                              umullt.  */
12456                                                           return 2299;
12457                                                         }
12458                                                     }
12459                                                 }
12460                                             }
12461                                           else
12462                                             {
12463                                               if (((word >> 23) & 0x1) == 0)
12464                                                 {
12465                                                   /* 33222222222211111111110000000000
12466                                                      10987654321098765432109876543210
12467                                                      110001x10x0xxxxx011xxxxxxxxxxxxx
12468                                                      ldff1w.  */
12469                                                   return 1709;
12470                                                 }
12471                                               else
12472                                                 {
12473                                                   /* 33222222222211111111110000000000
12474                                                      10987654321098765432109876543210
12475                                                      110001x11x0xxxxx011xxxxxxxxxxxxx
12476                                                      ldff1d.  */
12477                                                   return 1654;
12478                                                 }
12479                                             }
12480                                         }
12481                                       else
12482                                         {
12483                                           if (((word >> 31) & 0x1) == 0)
12484                                             {
12485                                               if (((word >> 10) & 0x1) == 0)
12486                                                 {
12487                                                   if (((word >> 11) & 0x1) == 0)
12488                                                     {
12489                                                       if (((word >> 12) & 0x1) == 0)
12490                                                         {
12491                                                           /* 33222222222211111111110000000000
12492                                                              10987654321098765432109876543210
12493                                                              010001x1xx1xxxxx011000xxxxxxxxxx
12494                                                              addhnb.  */
12495                                                           return 2063;
12496                                                         }
12497                                                       else
12498                                                         {
12499                                                           /* 33222222222211111111110000000000
12500                                                              10987654321098765432109876543210
12501                                                              010001x1xx1xxxxx011100xxxxxxxxxx
12502                                                              subhnb.  */
12503                                                           return 2261;
12504                                                         }
12505                                                     }
12506                                                   else
12507                                                     {
12508                                                       if (((word >> 12) & 0x1) == 0)
12509                                                         {
12510                                                           /* 33222222222211111111110000000000
12511                                                              10987654321098765432109876543210
12512                                                              010001x1xx1xxxxx011010xxxxxxxxxx
12513                                                              raddhnb.  */
12514                                                           return 2129;
12515                                                         }
12516                                                       else
12517                                                         {
12518                                                           /* 33222222222211111111110000000000
12519                                                              10987654321098765432109876543210
12520                                                              010001x1xx1xxxxx011110xxxxxxxxxx
12521                                                              rsubhnb.  */
12522                                                           return 2133;
12523                                                         }
12524                                                     }
12525                                                 }
12526                                               else
12527                                                 {
12528                                                   if (((word >> 11) & 0x1) == 0)
12529                                                     {
12530                                                       if (((word >> 12) & 0x1) == 0)
12531                                                         {
12532                                                           /* 33222222222211111111110000000000
12533                                                              10987654321098765432109876543210
12534                                                              010001x1xx1xxxxx011001xxxxxxxxxx
12535                                                              addhnt.  */
12536                                                           return 2064;
12537                                                         }
12538                                                       else
12539                                                         {
12540                                                           /* 33222222222211111111110000000000
12541                                                              10987654321098765432109876543210
12542                                                              010001x1xx1xxxxx011101xxxxxxxxxx
12543                                                              subhnt.  */
12544                                                           return 2262;
12545                                                         }
12546                                                     }
12547                                                   else
12548                                                     {
12549                                                       if (((word >> 12) & 0x1) == 0)
12550                                                         {
12551                                                           /* 33222222222211111111110000000000
12552                                                              10987654321098765432109876543210
12553                                                              010001x1xx1xxxxx011011xxxxxxxxxx
12554                                                              raddhnt.  */
12555                                                           return 2130;
12556                                                         }
12557                                                       else
12558                                                         {
12559                                                           /* 33222222222211111111110000000000
12560                                                              10987654321098765432109876543210
12561                                                              010001x1xx1xxxxx011111xxxxxxxxxx
12562                                                              rsubhnt.  */
12563                                                           return 2134;
12564                                                         }
12565                                                     }
12566                                                 }
12567                                             }
12568                                           else
12569                                             {
12570                                               if (((word >> 23) & 0x1) == 0)
12571                                                 {
12572                                                   /* 33222222222211111111110000000000
12573                                                      10987654321098765432109876543210
12574                                                      110001x10x1xxxxx011xxxxxxxxxxxxx
12575                                                      ldff1w.  */
12576                                                   return 1710;
12577                                                 }
12578                                               else
12579                                                 {
12580                                                   /* 33222222222211111111110000000000
12581                                                      10987654321098765432109876543210
12582                                                      110001x11x1xxxxx011xxxxxxxxxxxxx
12583                                                      ldff1d.  */
12584                                                   return 1655;
12585                                                 }
12586                                             }
12587                                         }
12588                                     }
12589                                   else
12590                                     {
12591                                       if (((word >> 21) & 0x1) == 0)
12592                                         {
12593                                           if (((word >> 31) & 0x1) == 0)
12594                                             {
12595                                               if (((word >> 10) & 0x1) == 0)
12596                                                 {
12597                                                   if (((word >> 11) & 0x1) == 0)
12598                                                     {
12599                                                       if (((word >> 12) & 0x1) == 0)
12600                                                         {
12601                                                           /* 33222222222211111111110000000000
12602                                                              10987654321098765432109876543210
12603                                                              010001x1xx0xxxxx111000xxxxxxxxxx
12604                                                              ssra.  */
12605                                                           return 2247;
12606                                                         }
12607                                                       else
12608                                                         {
12609                                                           /* 33222222222211111111110000000000
12610                                                              10987654321098765432109876543210
12611                                                              010001x1xx0xxxxx111100xxxxxxxxxx
12612                                                              sri.  */
12613                                                           return 2240;
12614                                                         }
12615                                                     }
12616                                                   else
12617                                                     {
12618                                                       if (((word >> 12) & 0x1) == 0)
12619                                                         {
12620                                                           /* 33222222222211111111110000000000
12621                                                              10987654321098765432109876543210
12622                                                              010001x1xx0xxxxx111010xxxxxxxxxx
12623                                                              srsra.  */
12624                                                           return 2244;
12625                                                         }
12626                                                       else
12627                                                         {
12628                                                           /* 33222222222211111111110000000000
12629                                                              10987654321098765432109876543210
12630                                                              010001x1xx0xxxxx111110xxxxxxxxxx
12631                                                              saba.  */
12632                                                           return 2135;
12633                                                         }
12634                                                     }
12635                                                 }
12636                                               else
12637                                                 {
12638                                                   if (((word >> 11) & 0x1) == 0)
12639                                                     {
12640                                                       if (((word >> 12) & 0x1) == 0)
12641                                                         {
12642                                                           /* 33222222222211111111110000000000
12643                                                              10987654321098765432109876543210
12644                                                              010001x1xx0xxxxx111001xxxxxxxxxx
12645                                                              usra.  */
12646                                                           return 2324;
12647                                                         }
12648                                                       else
12649                                                         {
12650                                                           /* 33222222222211111111110000000000
12651                                                              10987654321098765432109876543210
12652                                                              010001x1xx0xxxxx111101xxxxxxxxxx
12653                                                              sli.  */
12654                                                           return 2153;
12655                                                         }
12656                                                     }
12657                                                   else
12658                                                     {
12659                                                       if (((word >> 12) & 0x1) == 0)
12660                                                         {
12661                                                           /* 33222222222211111111110000000000
12662                                                              10987654321098765432109876543210
12663                                                              010001x1xx0xxxxx111011xxxxxxxxxx
12664                                                              ursra.  */
12665                                                           return 2320;
12666                                                         }
12667                                                       else
12668                                                         {
12669                                                           /* 33222222222211111111110000000000
12670                                                              10987654321098765432109876543210
12671                                                              010001x1xx0xxxxx111111xxxxxxxxxx
12672                                                              uaba.  */
12673                                                           return 2266;
12674                                                         }
12675                                                     }
12676                                                 }
12677                                             }
12678                                           else
12679                                             {
12680                                               if (((word >> 22) & 0x1) == 0)
12681                                                 {
12682                                                   if (((word >> 23) & 0x1) == 0)
12683                                                     {
12684                                                       /* 33222222222211111111110000000000
12685                                                          10987654321098765432109876543210
12686                                                          110001x1000xxxxx111xxxxxxxxxxxxx
12687                                                          prfw.  */
12688                                                       return 1805;
12689                                                     }
12690                                                   else
12691                                                     {
12692                                                       /* 33222222222211111111110000000000
12693                                                          10987654321098765432109876543210
12694                                                          110001x1100xxxxx111xxxxxxxxxxxxx
12695                                                          prfd.  */
12696                                                       return 1791;
12697                                                     }
12698                                                 }
12699                                               else
12700                                                 {
12701                                                   if (((word >> 23) & 0x1) == 0)
12702                                                     {
12703                                                       /* 33222222222211111111110000000000
12704                                                          10987654321098765432109876543210
12705                                                          110001x1010xxxxx111xxxxxxxxxxxxx
12706                                                          ldff1w.  */
12707                                                       return 1711;
12708                                                     }
12709                                                   else
12710                                                     {
12711                                                       /* 33222222222211111111110000000000
12712                                                          10987654321098765432109876543210
12713                                                          110001x1110xxxxx111xxxxxxxxxxxxx
12714                                                          ldff1d.  */
12715                                                       return 1656;
12716                                                     }
12717                                                 }
12718                                             }
12719                                         }
12720                                       else
12721                                         {
12722                                           if (((word >> 22) & 0x1) == 0)
12723                                             {
12724                                               if (((word >> 23) & 0x1) == 0)
12725                                                 {
12726                                                   if (((word >> 31) & 0x1) == 0)
12727                                                     {
12728                                                       if (((word >> 10) & 0x1) == 0)
12729                                                         {
12730                                                           if (((word >> 12) & 0x1) == 0)
12731                                                             {
12732                                                               if (((word >> 16) & 0x1) == 0)
12733                                                                 {
12734                                                                   if (((word >> 17) & 0x1) == 0)
12735                                                                     {
12736                                                                       /* 33222222222211111111110000000000
12737                                                                          10987654321098765432109876543210
12738                                                                          010001x1001xxx001110x0xxxxxxxxxx
12739                                                                          aesmc.  */
12740                                                                       return 2345;
12741                                                                     }
12742                                                                   else
12743                                                                     {
12744                                                                       /* 33222222222211111111110000000000
12745                                                                          10987654321098765432109876543210
12746                                                                          010001x1001xxx101110x0xxxxxxxxxx
12747                                                                          aese.  */
12748                                                                       return 2343;
12749                                                                     }
12750                                                                 }
12751                                                               else
12752                                                                 {
12753                                                                   /* 33222222222211111111110000000000
12754                                                                      10987654321098765432109876543210
12755                                                                      010001x1001xxxx11110x0xxxxxxxxxx
12756                                                                      sm4e.  */
12757                                                                   return 2340;
12758                                                                 }
12759                                                             }
12760                                                           else
12761                                                             {
12762                                                               /* 33222222222211111111110000000000
12763                                                                  10987654321098765432109876543210
12764                                                                  010001x1001xxxxx1111x0xxxxxxxxxx
12765                                                                  sm4ekey.  */
12766                                                               return 2341;
12767                                                             }
12768                                                         }
12769                                                       else
12770                                                         {
12771                                                           if (((word >> 12) & 0x1) == 0)
12772                                                             {
12773                                                               if (((word >> 17) & 0x1) == 0)
12774                                                                 {
12775                                                                   /* 33222222222211111111110000000000
12776                                                                      10987654321098765432109876543210
12777                                                                      010001x1001xxx0x1110x1xxxxxxxxxx
12778                                                                      aesimc.  */
12779                                                                   return 2344;
12780                                                                 }
12781                                                               else
12782                                                                 {
12783                                                                   /* 33222222222211111111110000000000
12784                                                                      10987654321098765432109876543210
12785                                                                      010001x1001xxx1x1110x1xxxxxxxxxx
12786                                                                      aesd.  */
12787                                                                   return 2342;
12788                                                                 }
12789                                                             }
12790                                                           else
12791                                                             {
12792                                                               /* 33222222222211111111110000000000
12793                                                                  10987654321098765432109876543210
12794                                                                  010001x1001xxxxx1111x1xxxxxxxxxx
12795                                                                  rax1.  */
12796                                                               return 2348;
12797                                                             }
12798                                                         }
12799                                                     }
12800                                                   else
12801                                                     {
12802                                                       /* 33222222222211111111110000000000
12803                                                          10987654321098765432109876543210
12804                                                          110001x1001xxxxx111xxxxxxxxxxxxx
12805                                                          ldff1w.  */
12806                                                       return 1714;
12807                                                     }
12808                                                 }
12809                                               else
12810                                                 {
12811                                                   /* 33222222222211111111110000000000
12812                                                      10987654321098765432109876543210
12813                                                      x10001x1101xxxxx111xxxxxxxxxxxxx
12814                                                      ldff1d.  */
12815                                                   return 1658;
12816                                                 }
12817                                             }
12818                                           else
12819                                             {
12820                                               if (((word >> 23) & 0x1) == 0)
12821                                                 {
12822                                                   /* 33222222222211111111110000000000
12823                                                      10987654321098765432109876543210
12824                                                      x10001x1011xxxxx111xxxxxxxxxxxxx
12825                                                      ldff1w.  */
12826                                                   return 1712;
12827                                                 }
12828                                               else
12829                                                 {
12830                                                   /* 33222222222211111111110000000000
12831                                                      10987654321098765432109876543210
12832                                                      x10001x1111xxxxx111xxxxxxxxxxxxx
12833                                                      ldff1d.  */
12834                                                   return 1657;
12835                                                 }
12836                                             }
12837                                         }
12838                                     }
12839                                 }
12840                             }
12841                         }
12842                     }
12843                   else
12844                     {
12845                       if (((word >> 15) & 0x1) == 0)
12846                         {
12847                           if (((word >> 14) & 0x1) == 0)
12848                             {
12849                               if (((word >> 13) & 0x1) == 0)
12850                                 {
12851                                   if (((word >> 30) & 0x1) == 0)
12852                                     {
12853                                       if (((word >> 21) & 0x1) == 0)
12854                                         {
12855                                           if (((word >> 31) & 0x1) == 0)
12856                                             {
12857                                               if (((word >> 4) & 0x1) == 0)
12858                                                 {
12859                                                   /* 33222222222211111111110000000000
12860                                                      10987654321098765432109876543210
12861                                                      001001x1xx0xxxxx000xxxxxxxx0xxxx
12862                                                      cmpge.  */
12863                                                   return 1337;
12864                                                 }
12865                                               else
12866                                                 {
12867                                                   /* 33222222222211111111110000000000
12868                                                      10987654321098765432109876543210
12869                                                      001001x1xx0xxxxx000xxxxxxxx1xxxx
12870                                                      cmpgt.  */
12871                                                   return 1340;
12872                                                 }
12873                                             }
12874                                           else
12875                                             {
12876                                               if (((word >> 23) & 0x1) == 0)
12877                                                 {
12878                                                   /* 33222222222211111111110000000000
12879                                                      10987654321098765432109876543210
12880                                                      101001x10x0xxxxx000xxxxxxxxxxxxx
12881                                                      ld1rqw.  */
12882                                                   return 1564;
12883                                                 }
12884                                               else
12885                                                 {
12886                                                   /* 33222222222211111111110000000000
12887                                                      10987654321098765432109876543210
12888                                                      101001x11x0xxxxx000xxxxxxxxxxxxx
12889                                                      ld1rqd.  */
12890                                                   return 1560;
12891                                                 }
12892                                             }
12893                                         }
12894                                       else
12895                                         {
12896                                           if (((word >> 31) & 0x1) == 0)
12897                                             {
12898                                               if (((word >> 4) & 0x1) == 0)
12899                                                 {
12900                                                   if (((word >> 10) & 0x1) == 0)
12901                                                     {
12902                                                       if (((word >> 11) & 0x1) == 0)
12903                                                         {
12904                                                           if (((word >> 12) & 0x1) == 0)
12905                                                             {
12906                                                               /* 33222222222211111111110000000000
12907                                                                  10987654321098765432109876543210
12908                                                                  001001x1xx1xxxxx000000xxxxx0xxxx
12909                                                                  whilege.  */
12910                                                               return 2329;
12911                                                             }
12912                                                           else
12913                                                             {
12914                                                               /* 33222222222211111111110000000000
12915                                                                  10987654321098765432109876543210
12916                                                                  001001x1xx1xxxxx000100xxxxx0xxxx
12917                                                                  whilege.  */
12918                                                               return 2330;
12919                                                             }
12920                                                         }
12921                                                       else
12922                                                         {
12923                                                           if (((word >> 12) & 0x1) == 0)
12924                                                             {
12925                                                               /* 33222222222211111111110000000000
12926                                                                  10987654321098765432109876543210
12927                                                                  001001x1xx1xxxxx000010xxxxx0xxxx
12928                                                                  whilehs.  */
12929                                                               return 2335;
12930                                                             }
12931                                                           else
12932                                                             {
12933                                                               /* 33222222222211111111110000000000
12934                                                                  10987654321098765432109876543210
12935                                                                  001001x1xx1xxxxx000110xxxxx0xxxx
12936                                                                  whilehs.  */
12937                                                               return 2336;
12938                                                             }
12939                                                         }
12940                                                     }
12941                                                   else
12942                                                     {
12943                                                       if (((word >> 11) & 0x1) == 0)
12944                                                         {
12945                                                           if (((word >> 12) & 0x1) == 0)
12946                                                             {
12947                                                               /* 33222222222211111111110000000000
12948                                                                  10987654321098765432109876543210
12949                                                                  001001x1xx1xxxxx000001xxxxx0xxxx
12950                                                                  whilelt.  */
12951                                                               return 2041;
12952                                                             }
12953                                                           else
12954                                                             {
12955                                                               /* 33222222222211111111110000000000
12956                                                                  10987654321098765432109876543210
12957                                                                  001001x1xx1xxxxx000101xxxxx0xxxx
12958                                                                  whilelt.  */
12959                                                               return 2042;
12960                                                             }
12961                                                         }
12962                                                       else
12963                                                         {
12964                                                           if (((word >> 12) & 0x1) == 0)
12965                                                             {
12966                                                               /* 33222222222211111111110000000000
12967                                                                  10987654321098765432109876543210
12968                                                                  001001x1xx1xxxxx000011xxxxx0xxxx
12969                                                                  whilelo.  */
12970                                                               return 2037;
12971                                                             }
12972                                                           else
12973                                                             {
12974                                                               /* 33222222222211111111110000000000
12975                                                                  10987654321098765432109876543210
12976                                                                  001001x1xx1xxxxx000111xxxxx0xxxx
12977                                                                  whilelo.  */
12978                                                               return 2038;
12979                                                             }
12980                                                         }
12981                                                     }
12982                                                 }
12983                                               else
12984                                                 {
12985                                                   if (((word >> 10) & 0x1) == 0)
12986                                                     {
12987                                                       if (((word >> 11) & 0x1) == 0)
12988                                                         {
12989                                                           if (((word >> 12) & 0x1) == 0)
12990                                                             {
12991                                                               /* 33222222222211111111110000000000
12992                                                                  10987654321098765432109876543210
12993                                                                  001001x1xx1xxxxx000000xxxxx1xxxx
12994                                                                  whilegt.  */
12995                                                               return 2331;
12996                                                             }
12997                                                           else
12998                                                             {
12999                                                               /* 33222222222211111111110000000000
13000                                                                  10987654321098765432109876543210
13001                                                                  001001x1xx1xxxxx000100xxxxx1xxxx
13002                                                                  whilegt.  */
13003                                                               return 2332;
13004                                                             }
13005                                                         }
13006                                                       else
13007                                                         {
13008                                                           if (((word >> 12) & 0x1) == 0)
13009                                                             {
13010                                                               /* 33222222222211111111110000000000
13011                                                                  10987654321098765432109876543210
13012                                                                  001001x1xx1xxxxx000010xxxxx1xxxx
13013                                                                  whilehi.  */
13014                                                               return 2333;
13015                                                             }
13016                                                           else
13017                                                             {
13018                                                               /* 33222222222211111111110000000000
13019                                                                  10987654321098765432109876543210
13020                                                                  001001x1xx1xxxxx000110xxxxx1xxxx
13021                                                                  whilehi.  */
13022                                                               return 2334;
13023                                                             }
13024                                                         }
13025                                                     }
13026                                                   else
13027                                                     {
13028                                                       if (((word >> 11) & 0x1) == 0)
13029                                                         {
13030                                                           if (((word >> 12) & 0x1) == 0)
13031                                                             {
13032                                                               /* 33222222222211111111110000000000
13033                                                                  10987654321098765432109876543210
13034                                                                  001001x1xx1xxxxx000001xxxxx1xxxx
13035                                                                  whilele.  */
13036                                                               return 2035;
13037                                                             }
13038                                                           else
13039                                                             {
13040                                                               /* 33222222222211111111110000000000
13041                                                                  10987654321098765432109876543210
13042                                                                  001001x1xx1xxxxx000101xxxxx1xxxx
13043                                                                  whilele.  */
13044                                                               return 2036;
13045                                                             }
13046                                                         }
13047                                                       else
13048                                                         {
13049                                                           if (((word >> 12) & 0x1) == 0)
13050                                                             {
13051                                                               /* 33222222222211111111110000000000
13052                                                                  10987654321098765432109876543210
13053                                                                  001001x1xx1xxxxx000011xxxxx1xxxx
13054                                                                  whilels.  */
13055                                                               return 2039;
13056                                                             }
13057                                                           else
13058                                                             {
13059                                                               /* 33222222222211111111110000000000
13060                                                                  10987654321098765432109876543210
13061                                                                  001001x1xx1xxxxx000111xxxxx1xxxx
13062                                                                  whilels.  */
13063                                                               return 2040;
13064                                                             }
13065                                                         }
13066                                                     }
13067                                                 }
13068                                             }
13069                                           else
13070                                             {
13071                                               if (((word >> 23) & 0x1) == 0)
13072                                                 {
13073                                                   /* 33222222222211111111110000000000
13074                                                      10987654321098765432109876543210
13075                                                      101001x10x1xxxxx000xxxxxxxxxxxxx
13076                                                      ld1row.  */
13077                                                   return 2474;
13078                                                 }
13079                                               else
13080                                                 {
13081                                                   /* 33222222222211111111110000000000
13082                                                      10987654321098765432109876543210
13083                                                      101001x11x1xxxxx000xxxxxxxxxxxxx
13084                                                      ld1rod.  */
13085                                                   return 2475;
13086                                                 }
13087                                             }
13088                                         }
13089                                     }
13090                                   else
13091                                     {
13092                                       if (((word >> 31) & 0x1) == 0)
13093                                         {
13094                                           if (((word >> 21) & 0x1) == 0)
13095                                             {
13096                                               if (((word >> 10) & 0x1) == 0)
13097                                                 {
13098                                                   if (((word >> 11) & 0x1) == 0)
13099                                                     {
13100                                                       /* 33222222222211111111110000000000
13101                                                          10987654321098765432109876543210
13102                                                          011001x1xx0xxxxx000x00xxxxxxxxxx
13103                                                          fadd.  */
13104                                                       return 1395;
13105                                                     }
13106                                                   else
13107                                                     {
13108                                                       if (((word >> 12) & 0x1) == 0)
13109                                                         {
13110                                                           /* 33222222222211111111110000000000
13111                                                              10987654321098765432109876543210
13112                                                              011001x1xx0xxxxx000010xxxxxxxxxx
13113                                                              fmul.  */
13114                                                           return 1462;
13115                                                         }
13116                                                       else
13117                                                         {
13118                                                           /* 33222222222211111111110000000000
13119                                                              10987654321098765432109876543210
13120                                                              011001x1xx0xxxxx000110xxxxxxxxxx
13121                                                              frecps.  */
13122                                                           return 1475;
13123                                                         }
13124                                                     }
13125                                                 }
13126                                               else
13127                                                 {
13128                                                   if (((word >> 11) & 0x1) == 0)
13129                                                     {
13130                                                       /* 33222222222211111111110000000000
13131                                                          10987654321098765432109876543210
13132                                                          011001x1xx0xxxxx000x01xxxxxxxxxx
13133                                                          fsub.  */
13134                                                       return 1488;
13135                                                     }
13136                                                   else
13137                                                     {
13138                                                       if (((word >> 12) & 0x1) == 0)
13139                                                         {
13140                                                           /* 33222222222211111111110000000000
13141                                                              10987654321098765432109876543210
13142                                                              011001x1xx0xxxxx000011xxxxxxxxxx
13143                                                              ftsmul.  */
13144                                                           return 1494;
13145                                                         }
13146                                                       else
13147                                                         {
13148                                                           /* 33222222222211111111110000000000
13149                                                              10987654321098765432109876543210
13150                                                              011001x1xx0xxxxx000111xxxxxxxxxx
13151                                                              frsqrts.  */
13152                                                           return 1485;
13153                                                         }
13154                                                     }
13155                                                 }
13156                                             }
13157                                           else
13158                                             {
13159                                               /* 33222222222211111111110000000000
13160                                                  10987654321098765432109876543210
13161                                                  011001x1xx1xxxxx000xxxxxxxxxxxxx
13162                                                  fmla.  */
13163                                               return 1453;
13164                                             }
13165                                         }
13166                                       else
13167                                         {
13168                                           /* 33222222222211111111110000000000
13169                                              10987654321098765432109876543210
13170                                              111001x1xxxxxxxx000xxxxxxxxxxxxx
13171                                              str.  */
13172                                           return 1956;
13173                                         }
13174                                     }
13175                                 }
13176                               else
13177                                 {
13178                                   if (((word >> 21) & 0x1) == 0)
13179                                     {
13180                                       if (((word >> 30) & 0x1) == 0)
13181                                         {
13182                                           if (((word >> 31) & 0x1) == 0)
13183                                             {
13184                                               if (((word >> 4) & 0x1) == 0)
13185                                                 {
13186                                                   /* 33222222222211111111110000000000
13187                                                      10987654321098765432109876543210
13188                                                      001001x1xx0xxxxx001xxxxxxxx0xxxx
13189                                                      cmplt.  */
13190                                                   return 1354;
13191                                                 }
13192                                               else
13193                                                 {
13194                                                   /* 33222222222211111111110000000000
13195                                                      10987654321098765432109876543210
13196                                                      001001x1xx0xxxxx001xxxxxxxx1xxxx
13197                                                      cmple.  */
13198                                                   return 1348;
13199                                                 }
13200                                             }
13201                                           else
13202                                             {
13203                                               if (((word >> 23) & 0x1) == 0)
13204                                                 {
13205                                                   /* 33222222222211111111110000000000
13206                                                      10987654321098765432109876543210
13207                                                      101001x10x0xxxxx001xxxxxxxxxxxxx
13208                                                      ld1rqw.  */
13209                                                   return 1563;
13210                                                 }
13211                                               else
13212                                                 {
13213                                                   /* 33222222222211111111110000000000
13214                                                      10987654321098765432109876543210
13215                                                      101001x11x0xxxxx001xxxxxxxxxxxxx
13216                                                      ld1rqd.  */
13217                                                   return 1559;
13218                                                 }
13219                                             }
13220                                         }
13221                                       else
13222                                         {
13223                                           if (((word >> 31) & 0x1) == 0)
13224                                             {
13225                                               if (((word >> 16) & 0x1) == 0)
13226                                                 {
13227                                                   if (((word >> 17) & 0x1) == 0)
13228                                                     {
13229                                                       if (((word >> 18) & 0x1) == 0)
13230                                                         {
13231                                                           if (((word >> 19) & 0x1) == 0)
13232                                                             {
13233                                                               if (((word >> 20) & 0x1) == 0)
13234                                                                 {
13235                                                                   /* 33222222222211111111110000000000
13236                                                                      10987654321098765432109876543210
13237                                                                      011001x1xx000000001xxxxxxxxxxxxx
13238                                                                      faddv.  */
13239                                                                   return 1399;
13240                                                                 }
13241                                                               else
13242                                                                 {
13243                                                                   if (((word >> 4) & 0x1) == 0)
13244                                                                     {
13245                                                                       /* 33222222222211111111110000000000
13246                                                                          10987654321098765432109876543210
13247                                                                          011001x1xx010000001xxxxxxxx0xxxx
13248                                                                          fcmge.  */
13249                                                                       return 1406;
13250                                                                     }
13251                                                                   else
13252                                                                     {
13253                                                                       /* 33222222222211111111110000000000
13254                                                                          10987654321098765432109876543210
13255                                                                          011001x1xx010000001xxxxxxxx1xxxx
13256                                                                          fcmgt.  */
13257                                                                       return 1408;
13258                                                                     }
13259                                                                 }
13260                                                             }
13261                                                           else
13262                                                             {
13263                                                               /* 33222222222211111111110000000000
13264                                                                  10987654321098765432109876543210
13265                                                                  011001x1xx0x1000001xxxxxxxxxxxxx
13266                                                                  fadda.  */
13267                                                               return 1398;
13268                                                             }
13269                                                         }
13270                                                       else
13271                                                         {
13272                                                           /* 33222222222211111111110000000000
13273                                                              10987654321098765432109876543210
13274                                                              011001x1xx0xx100001xxxxxxxxxxxxx
13275                                                              fmaxnmv.  */
13276                                                           return 1445;
13277                                                         }
13278                                                     }
13279                                                   else
13280                                                     {
13281                                                       if (((word >> 18) & 0x1) == 0)
13282                                                         {
13283                                                           /* 33222222222211111111110000000000
13284                                                              10987654321098765432109876543210
13285                                                              011001x1xx0xx010001xxxxxxxxxxxxx
13286                                                              fcmeq.  */
13287                                                           return 1404;
13288                                                         }
13289                                                       else
13290                                                         {
13291                                                           if (((word >> 19) & 0x1) == 0)
13292                                                             {
13293                                                               /* 33222222222211111111110000000000
13294                                                                  10987654321098765432109876543210
13295                                                                  011001x1xx0x0110001xxxxxxxxxxxxx
13296                                                                  fmaxv.  */
13297                                                               return 1446;
13298                                                             }
13299                                                           else
13300                                                             {
13301                                                               /* 33222222222211111111110000000000
13302                                                                  10987654321098765432109876543210
13303                                                                  011001x1xx0x1110001xxxxxxxxxxxxx
13304                                                                  frecpe.  */
13305                                                               return 1474;
13306                                                             }
13307                                                         }
13308                                                     }
13309                                                 }
13310                                               else
13311                                                 {
13312                                                   if (((word >> 17) & 0x1) == 0)
13313                                                     {
13314                                                       if (((word >> 18) & 0x1) == 0)
13315                                                         {
13316                                                           if (((word >> 4) & 0x1) == 0)
13317                                                             {
13318                                                               /* 33222222222211111111110000000000
13319                                                                  10987654321098765432109876543210
13320                                                                  011001x1xx0xx001001xxxxxxxx0xxxx
13321                                                                  fcmlt.  */
13322                                                               return 1411;
13323                                                             }
13324                                                           else
13325                                                             {
13326                                                               /* 33222222222211111111110000000000
13327                                                                  10987654321098765432109876543210
13328                                                                  011001x1xx0xx001001xxxxxxxx1xxxx
13329                                                                  fcmle.  */
13330                                                               return 1410;
13331                                                             }
13332                                                         }
13333                                                       else
13334                                                         {
13335                                                           /* 33222222222211111111110000000000
13336                                                              10987654321098765432109876543210
13337                                                              011001x1xx0xx101001xxxxxxxxxxxxx
13338                                                              fminnmv.  */
13339                                                           return 1451;
13340                                                         }
13341                                                     }
13342                                                   else
13343                                                     {
13344                                                       if (((word >> 18) & 0x1) == 0)
13345                                                         {
13346                                                           /* 33222222222211111111110000000000
13347                                                              10987654321098765432109876543210
13348                                                              011001x1xx0xx011001xxxxxxxxxxxxx
13349                                                              fcmne.  */
13350                                                           return 1412;
13351                                                         }
13352                                                       else
13353                                                         {
13354                                                           if (((word >> 19) & 0x1) == 0)
13355                                                             {
13356                                                               /* 33222222222211111111110000000000
13357                                                                  10987654321098765432109876543210
13358                                                                  011001x1xx0x0111001xxxxxxxxxxxxx
13359                                                                  fminv.  */
13360                                                               return 1452;
13361                                                             }
13362                                                           else
13363                                                             {
13364                                                               /* 33222222222211111111110000000000
13365                                                                  10987654321098765432109876543210
13366                                                                  011001x1xx0x1111001xxxxxxxxxxxxx
13367                                                                  frsqrte.  */
13368                                                               return 1484;
13369                                                             }
13370                                                         }
13371                                                     }
13372                                                 }
13373                                             }
13374                                           else
13375                                             {
13376                                               if (((word >> 22) & 0x1) == 0)
13377                                                 {
13378                                                   if (((word >> 23) & 0x1) == 0)
13379                                                     {
13380                                                       /* 33222222222211111111110000000000
13381                                                          10987654321098765432109876543210
13382                                                          111001x1000xxxxx001xxxxxxxxxxxxx
13383                                                          stnt1w.  */
13384                                                       return 2260;
13385                                                     }
13386                                                   else
13387                                                     {
13388                                                       /* 33222222222211111111110000000000
13389                                                          10987654321098765432109876543210
13390                                                          111001x1100xxxxx001xxxxxxxxxxxxx
13391                                                          stnt1d.  */
13392                                                       return 2256;
13393                                                     }
13394                                                 }
13395                                               else
13396                                                 {
13397                                                   /* 33222222222211111111110000000000
13398                                                      10987654321098765432109876543210
13399                                                      111001x1x10xxxxx001xxxxxxxxxxxxx
13400                                                      stnt1w.  */
13401                                                   return 2259;
13402                                                 }
13403                                             }
13404                                         }
13405                                     }
13406                                   else
13407                                     {
13408                                       if (((word >> 30) & 0x1) == 0)
13409                                         {
13410                                           if (((word >> 31) & 0x1) == 0)
13411                                             {
13412                                               if (((word >> 4) & 0x1) == 0)
13413                                                 {
13414                                                   if (((word >> 12) & 0x1) == 0)
13415                                                     {
13416                                                       /* 33222222222211111111110000000000
13417                                                          10987654321098765432109876543210
13418                                                          001001x1xx1xxxxx0010xxxxxxx0xxxx
13419                                                          ctermeq.  */
13420                                                       return 1369;
13421                                                     }
13422                                                   else
13423                                                     {
13424                                                       /* 33222222222211111111110000000000
13425                                                          10987654321098765432109876543210
13426                                                          001001x1xx1xxxxx0011xxxxxxx0xxxx
13427                                                          whilewr.  */
13428                                                       return 2338;
13429                                                     }
13430                                                 }
13431                                               else
13432                                                 {
13433                                                   if (((word >> 12) & 0x1) == 0)
13434                                                     {
13435                                                       /* 33222222222211111111110000000000
13436                                                          10987654321098765432109876543210
13437                                                          001001x1xx1xxxxx0010xxxxxxx1xxxx
13438                                                          ctermne.  */
13439                                                       return 1370;
13440                                                     }
13441                                                   else
13442                                                     {
13443                                                       /* 33222222222211111111110000000000
13444                                                          10987654321098765432109876543210
13445                                                          001001x1xx1xxxxx0011xxxxxxx1xxxx
13446                                                          whilerw.  */
13447                                                       return 2337;
13448                                                     }
13449                                                 }
13450                                             }
13451                                           else
13452                                             {
13453                                               if (((word >> 23) & 0x1) == 0)
13454                                                 {
13455                                                   /* 33222222222211111111110000000000
13456                                                      10987654321098765432109876543210
13457                                                      101001x10x1xxxxx001xxxxxxxxxxxxx
13458                                                      ld1row.  */
13459                                                   return 2478;
13460                                                 }
13461                                               else
13462                                                 {
13463                                                   /* 33222222222211111111110000000000
13464                                                      10987654321098765432109876543210
13465                                                      101001x11x1xxxxx001xxxxxxxxxxxxx
13466                                                      ld1rod.  */
13467                                                   return 2479;
13468                                                 }
13469                                             }
13470                                         }
13471                                       else
13472                                         {
13473                                           /* 33222222222211111111110000000000
13474                                              10987654321098765432109876543210
13475                                              x11001x1xx1xxxxx001xxxxxxxxxxxxx
13476                                              fmls.  */
13477                                           return 1457;
13478                                         }
13479                                     }
13480                                 }
13481                             }
13482                           else
13483                             {
13484                               if (((word >> 30) & 0x1) == 0)
13485                                 {
13486                                   if (((word >> 21) & 0x1) == 0)
13487                                     {
13488                                       if (((word >> 22) & 0x1) == 0)
13489                                         {
13490                                           if (((word >> 23) & 0x1) == 0)
13491                                             {
13492                                               if (((word >> 31) & 0x1) == 0)
13493                                                 {
13494                                                   if (((word >> 9) & 0x1) == 0)
13495                                                     {
13496                                                       if (((word >> 20) & 0x1) == 0)
13497                                                         {
13498                                                           if (((word >> 4) & 0x1) == 0)
13499                                                             {
13500                                                               /* 33222222222211111111110000000000
13501                                                                  10987654321098765432109876543210
13502                                                                  001001x10000xxxx01xxxx0xxxx0xxxx
13503                                                                  and.  */
13504                                                               return 1300;
13505                                                             }
13506                                                           else
13507                                                             {
13508                                                               /* 33222222222211111111110000000000
13509                                                                  10987654321098765432109876543210
13510                                                                  001001x10000xxxx01xxxx0xxxx1xxxx
13511                                                                  bic.  */
13512                                                               return 1312;
13513                                                             }
13514                                                         }
13515                                                       else
13516                                                         {
13517                                                           if (((word >> 19) & 0x1) == 0)
13518                                                             {
13519                                                               /* 33222222222211111111110000000000
13520                                                                  10987654321098765432109876543210
13521                                                                  001001x100010xxx01xxxx0xxxxxxxxx
13522                                                                  brka.  */
13523                                                               return 1314;
13524                                                             }
13525                                                           else
13526                                                             {
13527                                                               /* 33222222222211111111110000000000
13528                                                                  10987654321098765432109876543210
13529                                                                  001001x100011xxx01xxxx0xxxxxxxxx
13530                                                                  brkn.  */
13531                                                               return 1318;
13532                                                             }
13533                                                         }
13534                                                     }
13535                                                   else
13536                                                     {
13537                                                       if (((word >> 4) & 0x1) == 0)
13538                                                         {
13539                                                           /* 33222222222211111111110000000000
13540                                                              10987654321098765432109876543210
13541                                                              001001x1000xxxxx01xxxx1xxxx0xxxx
13542                                                              eor.  */
13543                                                           return 1387;
13544                                                         }
13545                                                       else
13546                                                         {
13547                                                           /* 33222222222211111111110000000000
13548                                                              10987654321098765432109876543210
13549                                                              001001x1000xxxxx01xxxx1xxxx1xxxx
13550                                                              sel.  */
13551                                                           return 1836;
13552                                                         }
13553                                                     }
13554                                                 }
13555                                               else
13556                                                 {
13557                                                   if (((word >> 13) & 0x1) == 0)
13558                                                     {
13559                                                       /* 33222222222211111111110000000000
13560                                                          10987654321098765432109876543210
13561                                                          101001x1000xxxxx010xxxxxxxxxxxxx
13562                                                          ld1sh.  */
13563                                                       return 1586;
13564                                                     }
13565                                                   else
13566                                                     {
13567                                                       /* 33222222222211111111110000000000
13568                                                          10987654321098765432109876543210
13569                                                          101001x1000xxxxx011xxxxxxxxxxxxx
13570                                                          ldff1sh.  */
13571                                                       return 1686;
13572                                                     }
13573                                                 }
13574                                             }
13575                                           else
13576                                             {
13577                                               if (((word >> 31) & 0x1) == 0)
13578                                                 {
13579                                                   if (((word >> 9) & 0x1) == 0)
13580                                                     {
13581                                                       if (((word >> 20) & 0x1) == 0)
13582                                                         {
13583                                                           if (((word >> 4) & 0x1) == 0)
13584                                                             {
13585                                                               /* 33222222222211111111110000000000
13586                                                                  10987654321098765432109876543210
13587                                                                  001001x11000xxxx01xxxx0xxxx0xxxx
13588                                                                  orr.  */
13589                                                               return 1772;
13590                                                             }
13591                                                           else
13592                                                             {
13593                                                               /* 33222222222211111111110000000000
13594                                                                  10987654321098765432109876543210
13595                                                                  001001x11000xxxx01xxxx0xxxx1xxxx
13596                                                                  orn.  */
13597                                                               return 1767;
13598                                                             }
13599                                                         }
13600                                                       else
13601                                                         {
13602                                                           /* 33222222222211111111110000000000
13603                                                              10987654321098765432109876543210
13604                                                              001001x11001xxxx01xxxx0xxxxxxxxx
13605                                                              brkb.  */
13606                                                           return 1316;
13607                                                         }
13608                                                     }
13609                                                   else
13610                                                     {
13611                                                       if (((word >> 4) & 0x1) == 0)
13612                                                         {
13613                                                           /* 33222222222211111111110000000000
13614                                                              10987654321098765432109876543210
13615                                                              001001x1100xxxxx01xxxx1xxxx0xxxx
13616                                                              nor.  */
13617                                                           return 1764;
13618                                                         }
13619                                                       else
13620                                                         {
13621                                                           /* 33222222222211111111110000000000
13622                                                              10987654321098765432109876543210
13623                                                              001001x1100xxxxx01xxxx1xxxx1xxxx
13624                                                              nand.  */
13625                                                           return 1761;
13626                                                         }
13627                                                     }
13628                                                 }
13629                                               else
13630                                                 {
13631                                                   if (((word >> 13) & 0x1) == 0)
13632                                                     {
13633                                                       /* 33222222222211111111110000000000
13634                                                          10987654321098765432109876543210
13635                                                          101001x1100xxxxx010xxxxxxxxxxxxx
13636                                                          ld1sb.  */
13637                                                       return 1574;
13638                                                     }
13639                                                   else
13640                                                     {
13641                                                       /* 33222222222211111111110000000000
13642                                                          10987654321098765432109876543210
13643                                                          101001x1100xxxxx011xxxxxxxxxxxxx
13644                                                          ldff1sb.  */
13645                                                       return 1674;
13646                                                     }
13647                                                 }
13648                                             }
13649                                         }
13650                                       else
13651                                         {
13652                                           if (((word >> 23) & 0x1) == 0)
13653                                             {
13654                                               if (((word >> 31) & 0x1) == 0)
13655                                                 {
13656                                                   if (((word >> 4) & 0x1) == 0)
13657                                                     {
13658                                                       if (((word >> 9) & 0x1) == 0)
13659                                                         {
13660                                                           if (((word >> 20) & 0x1) == 0)
13661                                                             {
13662                                                               /* 33222222222211111111110000000000
13663                                                                  10987654321098765432109876543210
13664                                                                  001001x10100xxxx01xxxx0xxxx0xxxx
13665                                                                  ands.  */
13666                                                               return 1301;
13667                                                             }
13668                                                           else
13669                                                             {
13670                                                               if (((word >> 19) & 0x1) == 0)
13671                                                                 {
13672                                                                   /* 33222222222211111111110000000000
13673                                                                      10987654321098765432109876543210
13674                                                                      001001x101010xxx01xxxx0xxxx0xxxx
13675                                                                      brkas.  */
13676                                                                   return 1315;
13677                                                                 }
13678                                                               else
13679                                                                 {
13680                                                                   /* 33222222222211111111110000000000
13681                                                                      10987654321098765432109876543210
13682                                                                      001001x101011xxx01xxxx0xxxx0xxxx
13683                                                                      brkns.  */
13684                                                                   return 1319;
13685                                                                 }
13686                                                             }
13687                                                         }
13688                                                       else
13689                                                         {
13690                                                           /* 33222222222211111111110000000000
13691                                                              10987654321098765432109876543210
13692                                                              001001x1010xxxxx01xxxx1xxxx0xxxx
13693                                                              eors.  */
13694                                                           return 1388;
13695                                                         }
13696                                                     }
13697                                                   else
13698                                                     {
13699                                                       /* 33222222222211111111110000000000
13700                                                          10987654321098765432109876543210
13701                                                          001001x1010xxxxx01xxxxxxxxx1xxxx
13702                                                          bics.  */
13703                                                       return 1313;
13704                                                     }
13705                                                 }
13706                                               else
13707                                                 {
13708                                                   if (((word >> 13) & 0x1) == 0)
13709                                                     {
13710                                                       /* 33222222222211111111110000000000
13711                                                          10987654321098765432109876543210
13712                                                          101001x1010xxxxx010xxxxxxxxxxxxx
13713                                                          ld1w.  */
13714                                                       return 1605;
13715                                                     }
13716                                                   else
13717                                                     {
13718                                                       /* 33222222222211111111110000000000
13719                                                          10987654321098765432109876543210
13720                                                          101001x1010xxxxx011xxxxxxxxxxxxx
13721                                                          ldff1w.  */
13722                                                       return 1705;
13723                                                     }
13724                                                 }
13725                                             }
13726                                           else
13727                                             {
13728                                               if (((word >> 31) & 0x1) == 0)
13729                                                 {
13730                                                   if (((word >> 4) & 0x1) == 0)
13731                                                     {
13732                                                       if (((word >> 9) & 0x1) == 0)
13733                                                         {
13734                                                           if (((word >> 20) & 0x1) == 0)
13735                                                             {
13736                                                               /* 33222222222211111111110000000000
13737                                                                  10987654321098765432109876543210
13738                                                                  001001x11100xxxx01xxxx0xxxx0xxxx
13739                                                                  orrs.  */
13740                                                               return 1773;
13741                                                             }
13742                                                           else
13743                                                             {
13744                                                               /* 33222222222211111111110000000000
13745                                                                  10987654321098765432109876543210
13746                                                                  001001x11101xxxx01xxxx0xxxx0xxxx
13747                                                                  brkbs.  */
13748                                                               return 1317;
13749                                                             }
13750                                                         }
13751                                                       else
13752                                                         {
13753                                                           /* 33222222222211111111110000000000
13754                                                              10987654321098765432109876543210
13755                                                              001001x1110xxxxx01xxxx1xxxx0xxxx
13756                                                              nors.  */
13757                                                           return 1765;
13758                                                         }
13759                                                     }
13760                                                   else
13761                                                     {
13762                                                       if (((word >> 9) & 0x1) == 0)
13763                                                         {
13764                                                           /* 33222222222211111111110000000000
13765                                                              10987654321098765432109876543210
13766                                                              001001x1110xxxxx01xxxx0xxxx1xxxx
13767                                                              orns.  */
13768                                                           return 1768;
13769                                                         }
13770                                                       else
13771                                                         {
13772                                                           /* 33222222222211111111110000000000
13773                                                              10987654321098765432109876543210
13774                                                              001001x1110xxxxx01xxxx1xxxx1xxxx
13775                                                              nands.  */
13776                                                           return 1762;
13777                                                         }
13778                                                     }
13779                                                 }
13780                                               else
13781                                                 {
13782                                                   if (((word >> 13) & 0x1) == 0)
13783                                                     {
13784                                                       /* 33222222222211111111110000000000
13785                                                          10987654321098765432109876543210
13786                                                          101001x1110xxxxx010xxxxxxxxxxxxx
13787                                                          ld1sb.  */
13788                                                       return 1576;
13789                                                     }
13790                                                   else
13791                                                     {
13792                                                       /* 33222222222211111111110000000000
13793                                                          10987654321098765432109876543210
13794                                                          101001x1110xxxxx011xxxxxxxxxxxxx
13795                                                          ldff1sb.  */
13796                                                       return 1678;
13797                                                     }
13798                                                 }
13799                                             }
13800                                         }
13801                                     }
13802                                   else
13803                                     {
13804                                       if (((word >> 31) & 0x1) == 0)
13805                                         {
13806                                           /* 33222222222211111111110000000000
13807                                              10987654321098765432109876543210
13808                                              001001x1xx1xxxxx01xxxxxxxxxxxxxx
13809                                              psel.  */
13810                                           return 2410;
13811                                         }
13812                                       else
13813                                         {
13814                                           if (((word >> 13) & 0x1) == 0)
13815                                             {
13816                                               if (((word >> 22) & 0x1) == 0)
13817                                                 {
13818                                                   if (((word >> 23) & 0x1) == 0)
13819                                                     {
13820                                                       /* 33222222222211111111110000000000
13821                                                          10987654321098765432109876543210
13822                                                          101001x1001xxxxx010xxxxxxxxxxxxx
13823                                                          ld1sh.  */
13824                                                       return 1587;
13825                                                     }
13826                                                   else
13827                                                     {
13828                                                       /* 33222222222211111111110000000000
13829                                                          10987654321098765432109876543210
13830                                                          101001x1101xxxxx010xxxxxxxxxxxxx
13831                                                          ld1sb.  */
13832                                                       return 1575;
13833                                                     }
13834                                                 }
13835                                               else
13836                                                 {
13837                                                   if (((word >> 23) & 0x1) == 0)
13838                                                     {
13839                                                       /* 33222222222211111111110000000000
13840                                                          10987654321098765432109876543210
13841                                                          101001x1011xxxxx010xxxxxxxxxxxxx
13842                                                          ld1w.  */
13843                                                       return 1606;
13844                                                     }
13845                                                   else
13846                                                     {
13847                                                       /* 33222222222211111111110000000000
13848                                                          10987654321098765432109876543210
13849                                                          101001x1111xxxxx010xxxxxxxxxxxxx
13850                                                          ld1d.  */
13851                                                       return 1528;
13852                                                     }
13853                                                 }
13854                                             }
13855                                           else
13856                                             {
13857                                               if (((word >> 22) & 0x1) == 0)
13858                                                 {
13859                                                   if (((word >> 23) & 0x1) == 0)
13860                                                     {
13861                                                       /* 33222222222211111111110000000000
13862                                                          10987654321098765432109876543210
13863                                                          101001x1001xxxxx011xxxxxxxxxxxxx
13864                                                          ldff1sh.  */
13865                                                       return 1688;
13866                                                     }
13867                                                   else
13868                                                     {
13869                                                       /* 33222222222211111111110000000000
13870                                                          10987654321098765432109876543210
13871                                                          101001x1101xxxxx011xxxxxxxxxxxxx
13872                                                          ldff1sb.  */
13873                                                       return 1676;
13874                                                     }
13875                                                 }
13876                                               else
13877                                                 {
13878                                                   if (((word >> 23) & 0x1) == 0)
13879                                                     {
13880                                                       /* 33222222222211111111110000000000
13881                                                          10987654321098765432109876543210
13882                                                          101001x1011xxxxx011xxxxxxxxxxxxx
13883                                                          ldff1w.  */
13884                                                       return 1707;
13885                                                     }
13886                                                   else
13887                                                     {
13888                                                       /* 33222222222211111111110000000000
13889                                                          10987654321098765432109876543210
13890                                                          101001x1111xxxxx011xxxxxxxxxxxxx
13891                                                          ldff1d.  */
13892                                                       return 1652;
13893                                                     }
13894                                                 }
13895                                             }
13896                                         }
13897                                     }
13898                                 }
13899                               else
13900                                 {
13901                                   if (((word >> 13) & 0x1) == 0)
13902                                     {
13903                                       if (((word >> 31) & 0x1) == 0)
13904                                         {
13905                                           if (((word >> 21) & 0x1) == 0)
13906                                             {
13907                                               if (((word >> 4) & 0x1) == 0)
13908                                                 {
13909                                                   /* 33222222222211111111110000000000
13910                                                      10987654321098765432109876543210
13911                                                      011001x1xx0xxxxx010xxxxxxxx0xxxx
13912                                                      fcmge.  */
13913                                                   return 1407;
13914                                                 }
13915                                               else
13916                                                 {
13917                                                   /* 33222222222211111111110000000000
13918                                                      10987654321098765432109876543210
13919                                                      011001x1xx0xxxxx010xxxxxxxx1xxxx
13920                                                      fcmgt.  */
13921                                                   return 1409;
13922                                                 }
13923                                             }
13924                                           else
13925                                             {
13926                                               /* 33222222222211111111110000000000
13927                                                  10987654321098765432109876543210
13928                                                  011001x1xx1xxxxx010xxxxxxxxxxxxx
13929                                                  fnmla.  */
13930                                               return 1471;
13931                                             }
13932                                         }
13933                                       else
13934                                         {
13935                                           if (((word >> 22) & 0x1) == 0)
13936                                             {
13937                                               /* 33222222222211111111110000000000
13938                                                  10987654321098765432109876543210
13939                                                  111001x1x0xxxxxx010xxxxxxxxxxxxx
13940                                                  str.  */
13941                                               return 1957;
13942                                             }
13943                                           else
13944                                             {
13945                                               if (((word >> 21) & 0x1) == 0)
13946                                                 {
13947                                                   /* 33222222222211111111110000000000
13948                                                      10987654321098765432109876543210
13949                                                      111001x1x10xxxxx010xxxxxxxxxxxxx
13950                                                      st1w.  */
13951                                                   return 1916;
13952                                                 }
13953                                               else
13954                                                 {
13955                                                   if (((word >> 23) & 0x1) == 0)
13956                                                     {
13957                                                       /* 33222222222211111111110000000000
13958                                                          10987654321098765432109876543210
13959                                                          111001x1011xxxxx010xxxxxxxxxxxxx
13960                                                          st1w.  */
13961                                                       return 1918;
13962                                                     }
13963                                                   else
13964                                                     {
13965                                                       /* 33222222222211111111110000000000
13966                                                          10987654321098765432109876543210
13967                                                          111001x1111xxxxx010xxxxxxxxxxxxx
13968                                                          st1d.  */
13969                                                       return 1895;
13970                                                     }
13971                                                 }
13972                                             }
13973                                         }
13974                                     }
13975                                   else
13976                                     {
13977                                       if (((word >> 21) & 0x1) == 0)
13978                                         {
13979                                           if (((word >> 31) & 0x1) == 0)
13980                                             {
13981                                               if (((word >> 4) & 0x1) == 0)
13982                                                 {
13983                                                   /* 33222222222211111111110000000000
13984                                                      10987654321098765432109876543210
13985                                                      011001x1xx0xxxxx011xxxxxxxx0xxxx
13986                                                      fcmeq.  */
13987                                                   return 1405;
13988                                                 }
13989                                               else
13990                                                 {
13991                                                   /* 33222222222211111111110000000000
13992                                                      10987654321098765432109876543210
13993                                                      011001x1xx0xxxxx011xxxxxxxx1xxxx
13994                                                      fcmne.  */
13995                                                   return 1413;
13996                                                 }
13997                                             }
13998                                           else
13999                                             {
14000                                               if (((word >> 22) & 0x1) == 0)
14001                                                 {
14002                                                   if (((word >> 23) & 0x1) == 0)
14003                                                     {
14004                                                       /* 33222222222211111111110000000000
14005                                                          10987654321098765432109876543210
14006                                                          111001x1000xxxxx011xxxxxxxxxxxxx
14007                                                          stnt1w.  */
14008                                                       return 1954;
14009                                                     }
14010                                                   else
14011                                                     {
14012                                                       /* 33222222222211111111110000000000
14013                                                          10987654321098765432109876543210
14014                                                          111001x1100xxxxx011xxxxxxxxxxxxx
14015                                                          stnt1d.  */
14016                                                       return 1950;
14017                                                     }
14018                                                 }
14019                                               else
14020                                                 {
14021                                                   if (((word >> 23) & 0x1) == 0)
14022                                                     {
14023                                                       /* 33222222222211111111110000000000
14024                                                          10987654321098765432109876543210
14025                                                          111001x1010xxxxx011xxxxxxxxxxxxx
14026                                                          st3w.  */
14027                                                       return 1938;
14028                                                     }
14029                                                   else
14030                                                     {
14031                                                       /* 33222222222211111111110000000000
14032                                                          10987654321098765432109876543210
14033                                                          111001x1110xxxxx011xxxxxxxxxxxxx
14034                                                          st3d.  */
14035                                                       return 1934;
14036                                                     }
14037                                                 }
14038                                             }
14039                                         }
14040                                       else
14041                                         {
14042                                           if (((word >> 31) & 0x1) == 0)
14043                                             {
14044                                               /* 33222222222211111111110000000000
14045                                                  10987654321098765432109876543210
14046                                                  011001x1xx1xxxxx011xxxxxxxxxxxxx
14047                                                  fnmls.  */
14048                                               return 1472;
14049                                             }
14050                                           else
14051                                             {
14052                                               if (((word >> 22) & 0x1) == 0)
14053                                                 {
14054                                                   if (((word >> 23) & 0x1) == 0)
14055                                                     {
14056                                                       /* 33222222222211111111110000000000
14057                                                          10987654321098765432109876543210
14058                                                          111001x1001xxxxx011xxxxxxxxxxxxx
14059                                                          st2w.  */
14060                                                       return 1930;
14061                                                     }
14062                                                   else
14063                                                     {
14064                                                       /* 33222222222211111111110000000000
14065                                                          10987654321098765432109876543210
14066                                                          111001x1101xxxxx011xxxxxxxxxxxxx
14067                                                          st2d.  */
14068                                                       return 1926;
14069                                                     }
14070                                                 }
14071                                               else
14072                                                 {
14073                                                   if (((word >> 23) & 0x1) == 0)
14074                                                     {
14075                                                       /* 33222222222211111111110000000000
14076                                                          10987654321098765432109876543210
14077                                                          111001x1011xxxxx011xxxxxxxxxxxxx
14078                                                          st4w.  */
14079                                                       return 1946;
14080                                                     }
14081                                                   else
14082                                                     {
14083                                                       /* 33222222222211111111110000000000
14084                                                          10987654321098765432109876543210
14085                                                          111001x1111xxxxx011xxxxxxxxxxxxx
14086                                                          st4d.  */
14087                                                       return 1942;
14088                                                     }
14089                                                 }
14090                                             }
14091                                         }
14092                                     }
14093                                 }
14094                             }
14095                         }
14096                       else
14097                         {
14098                           if (((word >> 21) & 0x1) == 0)
14099                             {
14100                               if (((word >> 30) & 0x1) == 0)
14101                                 {
14102                                   if (((word >> 14) & 0x1) == 0)
14103                                     {
14104                                       if (((word >> 13) & 0x1) == 0)
14105                                         {
14106                                           if (((word >> 4) & 0x1) == 0)
14107                                             {
14108                                               /* 33222222222211111111110000000000
14109                                                  10987654321098765432109876543210
14110                                                  x01001x1xx0xxxxx100xxxxxxxx0xxxx
14111                                                  cmpeq.  */
14112                                               return 1334;
14113                                             }
14114                                           else
14115                                             {
14116                                               /* 33222222222211111111110000000000
14117                                                  10987654321098765432109876543210
14118                                                  x01001x1xx0xxxxx100xxxxxxxx1xxxx
14119                                                  cmpne.  */
14120                                               return 1357;
14121                                             }
14122                                         }
14123                                       else
14124                                         {
14125                                           if (((word >> 20) & 0x1) == 0)
14126                                             {
14127                                               if (((word >> 22) & 0x1) == 0)
14128                                                 {
14129                                                   if (((word >> 23) & 0x1) == 0)
14130                                                     {
14131                                                       /* 33222222222211111111110000000000
14132                                                          10987654321098765432109876543210
14133                                                          x01001x10000xxxx101xxxxxxxxxxxxx
14134                                                          ld1sh.  */
14135                                                       return 1593;
14136                                                     }
14137                                                   else
14138                                                     {
14139                                                       /* 33222222222211111111110000000000
14140                                                          10987654321098765432109876543210
14141                                                          x01001x11000xxxx101xxxxxxxxxxxxx
14142                                                          ld1sb.  */
14143                                                       return 1580;
14144                                                     }
14145                                                 }
14146                                               else
14147                                                 {
14148                                                   if (((word >> 23) & 0x1) == 0)
14149                                                     {
14150                                                       /* 33222222222211111111110000000000
14151                                                          10987654321098765432109876543210
14152                                                          x01001x10100xxxx101xxxxxxxxxxxxx
14153                                                          ld1w.  */
14154                                                       return 1612;
14155                                                     }
14156                                                   else
14157                                                     {
14158                                                       /* 33222222222211111111110000000000
14159                                                          10987654321098765432109876543210
14160                                                          x01001x11100xxxx101xxxxxxxxxxxxx
14161                                                          ld1sb.  */
14162                                                       return 1582;
14163                                                     }
14164                                                 }
14165                                             }
14166                                           else
14167                                             {
14168                                               if (((word >> 22) & 0x1) == 0)
14169                                                 {
14170                                                   if (((word >> 23) & 0x1) == 0)
14171                                                     {
14172                                                       /* 33222222222211111111110000000000
14173                                                          10987654321098765432109876543210
14174                                                          x01001x10001xxxx101xxxxxxxxxxxxx
14175                                                          ldnf1sh.  */
14176                                                       return 1726;
14177                                                     }
14178                                                   else
14179                                                     {
14180                                                       /* 33222222222211111111110000000000
14181                                                          10987654321098765432109876543210
14182                                                          x01001x11001xxxx101xxxxxxxxxxxxx
14183                                                          ldnf1sb.  */
14184                                                       return 1723;
14185                                                     }
14186                                                 }
14187                                               else
14188                                                 {
14189                                                   if (((word >> 23) & 0x1) == 0)
14190                                                     {
14191                                                       /* 33222222222211111111110000000000
14192                                                          10987654321098765432109876543210
14193                                                          x01001x10101xxxx101xxxxxxxxxxxxx
14194                                                          ldnf1w.  */
14195                                                       return 1729;
14196                                                     }
14197                                                   else
14198                                                     {
14199                                                       /* 33222222222211111111110000000000
14200                                                          10987654321098765432109876543210
14201                                                          x01001x11101xxxx101xxxxxxxxxxxxx
14202                                                          ldnf1sb.  */
14203                                                       return 1725;
14204                                                     }
14205                                                 }
14206                                             }
14207                                         }
14208                                     }
14209                                   else
14210                                     {
14211                                       if (((word >> 31) & 0x1) == 0)
14212                                         {
14213                                           if (((word >> 4) & 0x1) == 0)
14214                                             {
14215                                               if (((word >> 20) & 0x1) == 0)
14216                                                 {
14217                                                   if (((word >> 22) & 0x1) == 0)
14218                                                     {
14219                                                       /* 33222222222211111111110000000000
14220                                                          10987654321098765432109876543210
14221                                                          001001x1x000xxxx11xxxxxxxxx0xxxx
14222                                                          brkpa.  */
14223                                                       return 1320;
14224                                                     }
14225                                                   else
14226                                                     {
14227                                                       /* 33222222222211111111110000000000
14228                                                          10987654321098765432109876543210
14229                                                          001001x1x100xxxx11xxxxxxxxx0xxxx
14230                                                          brkpas.  */
14231                                                       return 1321;
14232                                                     }
14233                                                 }
14234                                               else
14235                                                 {
14236                                                   if (((word >> 16) & 0x1) == 0)
14237                                                     {
14238                                                       if (((word >> 19) & 0x1) == 0)
14239                                                         {
14240                                                           /* 33222222222211111111110000000000
14241                                                              10987654321098765432109876543210
14242                                                              001001x1xx010xx011xxxxxxxxx0xxxx
14243                                                              ptest.  */
14244                                                           return 1806;
14245                                                         }
14246                                                       else
14247                                                         {
14248                                                           if (((word >> 10) & 0x1) == 0)
14249                                                             {
14250                                                               if (((word >> 12) & 0x1) == 0)
14251                                                                 {
14252                                                                   if (((word >> 13) & 0x1) == 0)
14253                                                                     {
14254                                                                       /* 33222222222211111111110000000000
14255                                                                          10987654321098765432109876543210
14256                                                                          001001x1xx011xx01100x0xxxxx0xxxx
14257                                                                          pfirst.  */
14258                                                                       return 1776;
14259                                                                     }
14260                                                                   else
14261                                                                     {
14262                                                                       /* 33222222222211111111110000000000
14263                                                                          10987654321098765432109876543210
14264                                                                          001001x1xx011xx01110x0xxxxx0xxxx
14265                                                                          ptrue.  */
14266                                                                       return 1807;
14267                                                                     }
14268                                                                 }
14269                                                               else
14270                                                                 {
14271                                                                   if (((word >> 22) & 0x1) == 0)
14272                                                                     {
14273                                                                       /* 33222222222211111111110000000000
14274                                                                          10987654321098765432109876543210
14275                                                                          001001x1x0011xx011x1x0xxxxx0xxxx
14276                                                                          rdffr.  */
14277                                                                       return 1813;
14278                                                                     }
14279                                                                   else
14280                                                                     {
14281                                                                       /* 33222222222211111111110000000000
14282                                                                          10987654321098765432109876543210
14283                                                                          001001x1x1011xx011x1x0xxxxx0xxxx
14284                                                                          rdffrs.  */
14285                                                                       return 1814;
14286                                                                     }
14287                                                                 }
14288                                                             }
14289                                                           else
14290                                                             {
14291                                                               /* 33222222222211111111110000000000
14292                                                                  10987654321098765432109876543210
14293                                                                  001001x1xx011xx011xxx1xxxxx0xxxx
14294                                                                  pfalse.  */
14295                                                               return 1775;
14296                                                             }
14297                                                         }
14298                                                     }
14299                                                   else
14300                                                     {
14301                                                       if (((word >> 10) & 0x1) == 0)
14302                                                         {
14303                                                           if (((word >> 12) & 0x1) == 0)
14304                                                             {
14305                                                               /* 33222222222211111111110000000000
14306                                                                  10987654321098765432109876543210
14307                                                                  001001x1xx01xxx111x0x0xxxxx0xxxx
14308                                                                  ptrues.  */
14309                                                               return 1808;
14310                                                             }
14311                                                           else
14312                                                             {
14313                                                               /* 33222222222211111111110000000000
14314                                                                  10987654321098765432109876543210
14315                                                                  001001x1xx01xxx111x1x0xxxxx0xxxx
14316                                                                  rdffr.  */
14317                                                               return 1812;
14318                                                             }
14319                                                         }
14320                                                       else
14321                                                         {
14322                                                           /* 33222222222211111111110000000000
14323                                                              10987654321098765432109876543210
14324                                                              001001x1xx01xxx111xxx1xxxxx0xxxx
14325                                                              pnext.  */
14326                                                           return 1777;
14327                                                         }
14328                                                     }
14329                                                 }
14330                                             }
14331                                           else
14332                                             {
14333                                               if (((word >> 22) & 0x1) == 0)
14334                                                 {
14335                                                   /* 33222222222211111111110000000000
14336                                                      10987654321098765432109876543210
14337                                                      001001x1x00xxxxx11xxxxxxxxx1xxxx
14338                                                      brkpb.  */
14339                                                   return 1322;
14340                                                 }
14341                                               else
14342                                                 {
14343                                                   /* 33222222222211111111110000000000
14344                                                      10987654321098765432109876543210
14345                                                      001001x1x10xxxxx11xxxxxxxxx1xxxx
14346                                                      brkpbs.  */
14347                                                   return 1323;
14348                                                 }
14349                                             }
14350                                         }
14351                                       else
14352                                         {
14353                                           if (((word >> 13) & 0x1) == 0)
14354                                             {
14355                                               if (((word >> 22) & 0x1) == 0)
14356                                                 {
14357                                                   if (((word >> 23) & 0x1) == 0)
14358                                                     {
14359                                                       /* 33222222222211111111110000000000
14360                                                          10987654321098765432109876543210
14361                                                          101001x1000xxxxx110xxxxxxxxxxxxx
14362                                                          ldnt1w.  */
14363                                                       return 1737;
14364                                                     }
14365                                                   else
14366                                                     {
14367                                                       /* 33222222222211111111110000000000
14368                                                          10987654321098765432109876543210
14369                                                          101001x1100xxxxx110xxxxxxxxxxxxx
14370                                                          ldnt1d.  */
14371                                                       return 1733;
14372                                                     }
14373                                                 }
14374                                               else
14375                                                 {
14376                                                   if (((word >> 23) & 0x1) == 0)
14377                                                     {
14378                                                       /* 33222222222211111111110000000000
14379                                                          10987654321098765432109876543210
14380                                                          101001x1010xxxxx110xxxxxxxxxxxxx
14381                                                          ld3w.  */
14382                                                       return 1629;
14383                                                     }
14384                                                   else
14385                                                     {
14386                                                       /* 33222222222211111111110000000000
14387                                                          10987654321098765432109876543210
14388                                                          101001x1110xxxxx110xxxxxxxxxxxxx
14389                                                          ld3d.  */
14390                                                       return 1625;
14391                                                     }
14392                                                 }
14393                                             }
14394                                           else
14395                                             {
14396                                               if (((word >> 22) & 0x1) == 0)
14397                                                 {
14398                                                   if (((word >> 23) & 0x1) == 0)
14399                                                     {
14400                                                       /* 33222222222211111111110000000000
14401                                                          10987654321098765432109876543210
14402                                                          101001x1000xxxxx111xxxxxxxxxxxxx
14403                                                          ldnt1w.  */
14404                                                       return 1738;
14405                                                     }
14406                                                   else
14407                                                     {
14408                                                       /* 33222222222211111111110000000000
14409                                                          10987654321098765432109876543210
14410                                                          101001x1100xxxxx111xxxxxxxxxxxxx
14411                                                          ldnt1d.  */
14412                                                       return 1734;
14413                                                     }
14414                                                 }
14415                                               else
14416                                                 {
14417                                                   if (((word >> 23) & 0x1) == 0)
14418                                                     {
14419                                                       /* 33222222222211111111110000000000
14420                                                          10987654321098765432109876543210
14421                                                          101001x1010xxxxx111xxxxxxxxxxxxx
14422                                                          ld3w.  */
14423                                                       return 1630;
14424                                                     }
14425                                                   else
14426                                                     {
14427                                                       /* 33222222222211111111110000000000
14428                                                          10987654321098765432109876543210
14429                                                          101001x1110xxxxx111xxxxxxxxxxxxx
14430                                                          ld3d.  */
14431                                                       return 1626;
14432                                                     }
14433                                                 }
14434                                             }
14435                                         }
14436                                     }
14437                                 }
14438                               else
14439                                 {
14440                                   if (((word >> 13) & 0x1) == 0)
14441                                     {
14442                                       if (((word >> 31) & 0x1) == 0)
14443                                         {
14444                                           if (((word >> 14) & 0x1) == 0)
14445                                             {
14446                                               if (((word >> 19) & 0x1) == 0)
14447                                                 {
14448                                                   if (((word >> 20) & 0x1) == 0)
14449                                                     {
14450                                                       if (((word >> 16) & 0x1) == 0)
14451                                                         {
14452                                                           if (((word >> 17) & 0x1) == 0)
14453                                                             {
14454                                                               if (((word >> 18) & 0x1) == 0)
14455                                                                 {
14456                                                                   /* 33222222222211111111110000000000
14457                                                                      10987654321098765432109876543210
14458                                                                      011001x1xx000000100xxxxxxxxxxxxx
14459                                                                      fadd.  */
14460                                                                   return 1396;
14461                                                                 }
14462                                                               else
14463                                                                 {
14464                                                                   /* 33222222222211111111110000000000
14465                                                                      10987654321098765432109876543210
14466                                                                      011001x1xx000100100xxxxxxxxxxxxx
14467                                                                      fmaxnm.  */
14468                                                                   return 1443;
14469                                                                 }
14470                                                             }
14471                                                           else
14472                                                             {
14473                                                               if (((word >> 18) & 0x1) == 0)
14474                                                                 {
14475                                                                   /* 33222222222211111111110000000000
14476                                                                      10987654321098765432109876543210
14477                                                                      011001x1xx000010100xxxxxxxxxxxxx
14478                                                                      fmul.  */
14479                                                                   return 1463;
14480                                                                 }
14481                                                               else
14482                                                                 {
14483                                                                   /* 33222222222211111111110000000000
14484                                                                      10987654321098765432109876543210
14485                                                                      011001x1xx000110100xxxxxxxxxxxxx
14486                                                                      fmax.  */
14487                                                                   return 1441;
14488                                                                 }
14489                                                             }
14490                                                         }
14491                                                       else
14492                                                         {
14493                                                           if (((word >> 17) & 0x1) == 0)
14494                                                             {
14495                                                               if (((word >> 18) & 0x1) == 0)
14496                                                                 {
14497                                                                   /* 33222222222211111111110000000000
14498                                                                      10987654321098765432109876543210
14499                                                                      011001x1xx000001100xxxxxxxxxxxxx
14500                                                                      fsub.  */
14501                                                                   return 1489;
14502                                                                 }
14503                                                               else
14504                                                                 {
14505                                                                   /* 33222222222211111111110000000000
14506                                                                      10987654321098765432109876543210
14507                                                                      011001x1xx000101100xxxxxxxxxxxxx
14508                                                                      fminnm.  */
14509                                                                   return 1449;
14510                                                                 }
14511                                                             }
14512                                                           else
14513                                                             {
14514                                                               if (((word >> 18) & 0x1) == 0)
14515                                                                 {
14516                                                                   /* 33222222222211111111110000000000
14517                                                                      10987654321098765432109876543210
14518                                                                      011001x1xx000011100xxxxxxxxxxxxx
14519                                                                      fsubr.  */
14520                                                                   return 1491;
14521                                                                 }
14522                                                               else
14523                                                                 {
14524                                                                   /* 33222222222211111111110000000000
14525                                                                      10987654321098765432109876543210
14526                                                                      011001x1xx000111100xxxxxxxxxxxxx
14527                                                                      fmin.  */
14528                                                                   return 1447;
14529                                                                 }
14530                                                             }
14531                                                         }
14532                                                     }
14533                                                   else
14534                                                     {
14535                                                       /* 33222222222211111111110000000000
14536                                                          10987654321098765432109876543210
14537                                                          011001x1xx010xxx100xxxxxxxxxxxxx
14538                                                          ftmad.  */
14539                                                       return 1493;
14540                                                     }
14541                                                 }
14542                                               else
14543                                                 {
14544                                                   if (((word >> 16) & 0x1) == 0)
14545                                                     {
14546                                                       if (((word >> 17) & 0x1) == 0)
14547                                                         {
14548                                                           if (((word >> 18) & 0x1) == 0)
14549                                                             {
14550                                                               if (((word >> 20) & 0x1) == 0)
14551                                                                 {
14552                                                                   /* 33222222222211111111110000000000
14553                                                                      10987654321098765432109876543210
14554                                                                      011001x1xx001000100xxxxxxxxxxxxx
14555                                                                      fabd.  */
14556                                                                   return 1391;
14557                                                                 }
14558                                                               else
14559                                                                 {
14560                                                                   /* 33222222222211111111110000000000
14561                                                                      10987654321098765432109876543210
14562                                                                      011001x1xx011000100xxxxxxxxxxxxx
14563                                                                      fadd.  */
14564                                                                   return 1397;
14565                                                                 }
14566                                                             }
14567                                                           else
14568                                                             {
14569                                                               if (((word >> 20) & 0x1) == 0)
14570                                                                 {
14571                                                                   /* 33222222222211111111110000000000
14572                                                                      10987654321098765432109876543210
14573                                                                      011001x1xx001100100xxxxxxxxxxxxx
14574                                                                      fdivr.  */
14575                                                                   return 1437;
14576                                                                 }
14577                                                               else
14578                                                                 {
14579                                                                   /* 33222222222211111111110000000000
14580                                                                      10987654321098765432109876543210
14581                                                                      011001x1xx011100100xxxxxxxxxxxxx
14582                                                                      fmaxnm.  */
14583                                                                   return 1444;
14584                                                                 }
14585                                                             }
14586                                                         }
14587                                                       else
14588                                                         {
14589                                                           if (((word >> 18) & 0x1) == 0)
14590                                                             {
14591                                                               if (((word >> 20) & 0x1) == 0)
14592                                                                 {
14593                                                                   /* 33222222222211111111110000000000
14594                                                                      10987654321098765432109876543210
14595                                                                      011001x1xx001010100xxxxxxxxxxxxx
14596                                                                      fmulx.  */
14597                                                                   return 1468;
14598                                                                 }
14599                                                               else
14600                                                                 {
14601                                                                   /* 33222222222211111111110000000000
14602                                                                      10987654321098765432109876543210
14603                                                                      011001x1xx011010100xxxxxxxxxxxxx
14604                                                                      fmul.  */
14605                                                                   return 1464;
14606                                                                 }
14607                                                             }
14608                                                           else
14609                                                             {
14610                                                               /* 33222222222211111111110000000000
14611                                                                  10987654321098765432109876543210
14612                                                                  011001x1xx0x1110100xxxxxxxxxxxxx
14613                                                                  fmax.  */
14614                                                               return 1442;
14615                                                             }
14616                                                         }
14617                                                     }
14618                                                   else
14619                                                     {
14620                                                       if (((word >> 17) & 0x1) == 0)
14621                                                         {
14622                                                           if (((word >> 18) & 0x1) == 0)
14623                                                             {
14624                                                               if (((word >> 20) & 0x1) == 0)
14625                                                                 {
14626                                                                   /* 33222222222211111111110000000000
14627                                                                      10987654321098765432109876543210
14628                                                                      011001x1xx001001100xxxxxxxxxxxxx
14629                                                                      fscale.  */
14630                                                                   return 1486;
14631                                                                 }
14632                                                               else
14633                                                                 {
14634                                                                   /* 33222222222211111111110000000000
14635                                                                      10987654321098765432109876543210
14636                                                                      011001x1xx011001100xxxxxxxxxxxxx
14637                                                                      fsub.  */
14638                                                                   return 1490;
14639                                                                 }
14640                                                             }
14641                                                           else
14642                                                             {
14643                                                               if (((word >> 20) & 0x1) == 0)
14644                                                                 {
14645                                                                   /* 33222222222211111111110000000000
14646                                                                      10987654321098765432109876543210
14647                                                                      011001x1xx001101100xxxxxxxxxxxxx
14648                                                                      fdiv.  */
14649                                                                   return 1436;
14650                                                                 }
14651                                                               else
14652                                                                 {
14653                                                                   /* 33222222222211111111110000000000
14654                                                                      10987654321098765432109876543210
14655                                                                      011001x1xx011101100xxxxxxxxxxxxx
14656                                                                      fminnm.  */
14657                                                                   return 1450;
14658                                                                 }
14659                                                             }
14660                                                         }
14661                                                       else
14662                                                         {
14663                                                           if (((word >> 18) & 0x1) == 0)
14664                                                             {
14665                                                               /* 33222222222211111111110000000000
14666                                                                  10987654321098765432109876543210
14667                                                                  011001x1xx0x1011100xxxxxxxxxxxxx
14668                                                                  fsubr.  */
14669                                                               return 1492;
14670                                                             }
14671                                                           else
14672                                                             {
14673                                                               /* 33222222222211111111110000000000
14674                                                                  10987654321098765432109876543210
14675                                                                  011001x1xx0x1111100xxxxxxxxxxxxx
14676                                                                  fmin.  */
14677                                                               return 1448;
14678                                                             }
14679                                                         }
14680                                                     }
14681                                                 }
14682                                             }
14683                                           else
14684                                             {
14685                                               if (((word >> 4) & 0x1) == 0)
14686                                                 {
14687                                                   /* 33222222222211111111110000000000
14688                                                      10987654321098765432109876543210
14689                                                      011001x1xx0xxxxx110xxxxxxxx0xxxx
14690                                                      fcmuo.  */
14691                                                   return 1414;
14692                                                 }
14693                                               else
14694                                                 {
14695                                                   /* 33222222222211111111110000000000
14696                                                      10987654321098765432109876543210
14697                                                      011001x1xx0xxxxx110xxxxxxxx1xxxx
14698                                                      facge.  */
14699                                                   return 1393;
14700                                                 }
14701                                             }
14702                                         }
14703                                       else
14704                                         {
14705                                           if (((word >> 22) & 0x1) == 0)
14706                                             {
14707                                               if (((word >> 23) & 0x1) == 0)
14708                                                 {
14709                                                   /* 33222222222211111111110000000000
14710                                                      10987654321098765432109876543210
14711                                                      111001x1000xxxxx1x0xxxxxxxxxxxxx
14712                                                      st1w.  */
14713                                                   return 1912;
14714                                                 }
14715                                               else
14716                                                 {
14717                                                   /* 33222222222211111111110000000000
14718                                                      10987654321098765432109876543210
14719                                                      111001x1100xxxxx1x0xxxxxxxxxxxxx
14720                                                      st1d.  */
14721                                                   return 1891;
14722                                                 }
14723                                             }
14724                                           else
14725                                             {
14726                                               /* 33222222222211111111110000000000
14727                                                  10987654321098765432109876543210
14728                                                  111001x1x10xxxxx1x0xxxxxxxxxxxxx
14729                                                  st1w.  */
14730                                               return 1917;
14731                                             }
14732                                         }
14733                                     }
14734                                   else
14735                                     {
14736                                       if (((word >> 14) & 0x1) == 0)
14737                                         {
14738                                           if (((word >> 31) & 0x1) == 0)
14739                                             {
14740                                               if (((word >> 16) & 0x1) == 0)
14741                                                 {
14742                                                   if (((word >> 19) & 0x1) == 0)
14743                                                     {
14744                                                       if (((word >> 17) & 0x1) == 0)
14745                                                         {
14746                                                           if (((word >> 18) & 0x1) == 0)
14747                                                             {
14748                                                               if (((word >> 20) & 0x1) == 0)
14749                                                                 {
14750                                                                   /* 33222222222211111111110000000000
14751                                                                      10987654321098765432109876543210
14752                                                                      011001x1xx000000101xxxxxxxxxxxxx
14753                                                                      frintn.  */
14754                                                                   return 1480;
14755                                                                 }
14756                                                               else
14757                                                                 {
14758                                                                   /* 33222222222211111111110000000000
14759                                                                      10987654321098765432109876543210
14760                                                                      011001x1xx010000101xxxxxxxxxxxxx
14761                                                                      scvtf.  */
14762                                                                   return 1826;
14763                                                                 }
14764                                                             }
14765                                                           else
14766                                                             {
14767                                                               if (((word >> 20) & 0x1) == 0)
14768                                                                 {
14769                                                                   /* 33222222222211111111110000000000
14770                                                                      10987654321098765432109876543210
14771                                                                      011001x1xx000100101xxxxxxxxxxxxx
14772                                                                      frinta.  */
14773                                                                   return 1477;
14774                                                                 }
14775                                                               else
14776                                                                 {
14777                                                                   if (((word >> 22) & 0x1) == 0)
14778                                                                     {
14779                                                                       /* 33222222222211111111110000000000
14780                                                                          10987654321098765432109876543210
14781                                                                          011001x1x0010100101xxxxxxxxxxxxx
14782                                                                          scvtf.  */
14783                                                                       return 1825;
14784                                                                     }
14785                                                                   else
14786                                                                     {
14787                                                                       if (((word >> 23) & 0x1) == 0)
14788                                                                         {
14789                                                                           /* 33222222222211111111110000000000
14790                                                                              10987654321098765432109876543210
14791                                                                              011001x101010100101xxxxxxxxxxxxx
14792                                                                              scvtf.  */
14793                                                                           return 1824;
14794                                                                         }
14795                                                                       else
14796                                                                         {
14797                                                                           /* 33222222222211111111110000000000
14798                                                                              10987654321098765432109876543210
14799                                                                              011001x111010100101xxxxxxxxxxxxx
14800                                                                              scvtf.  */
14801                                                                           return 1828;
14802                                                                         }
14803                                                                     }
14804                                                                 }
14805                                                             }
14806                                                         }
14807                                                       else
14808                                                         {
14809                                                           if (((word >> 18) & 0x1) == 0)
14810                                                             {
14811                                                               if (((word >> 20) & 0x1) == 0)
14812                                                                 {
14813                                                                   /* 33222222222211111111110000000000
14814                                                                      10987654321098765432109876543210
14815                                                                      011001x1xx000010101xxxxxxxxxxxxx
14816                                                                      frintm.  */
14817                                                                   return 1479;
14818                                                                 }
14819                                                               else
14820                                                                 {
14821                                                                   /* 33222222222211111111110000000000
14822                                                                      10987654321098765432109876543210
14823                                                                      011001x1xx010010101xxxxxxxxxxxxx
14824                                                                      scvtf.  */
14825                                                                   return 1823;
14826                                                                 }
14827                                                             }
14828                                                           else
14829                                                             {
14830                                                               if (((word >> 20) & 0x1) == 0)
14831                                                                 {
14832                                                                   /* 33222222222211111111110000000000
14833                                                                      10987654321098765432109876543210
14834                                                                      011001x1xx000110101xxxxxxxxxxxxx
14835                                                                      frintx.  */
14836                                                                   return 1482;
14837                                                                 }
14838                                                               else
14839                                                                 {
14840                                                                   if (((word >> 23) & 0x1) == 0)
14841                                                                     {
14842                                                                       /* 33222222222211111111110000000000
14843                                                                          10987654321098765432109876543210
14844                                                                          011001x10x010110101xxxxxxxxxxxxx
14845                                                                          scvtf.  */
14846                                                                       return 1827;
14847                                                                     }
14848                                                                   else
14849                                                                     {
14850                                                                       /* 33222222222211111111110000000000
14851                                                                          10987654321098765432109876543210
14852                                                                          011001x11x010110101xxxxxxxxxxxxx
14853                                                                          scvtf.  */
14854                                                                       return 1829;
14855                                                                     }
14856                                                                 }
14857                                                             }
14858                                                         }
14859                                                     }
14860                                                   else
14861                                                     {
14862                                                       if (((word >> 20) & 0x1) == 0)
14863                                                         {
14864                                                           if (((word >> 17) & 0x1) == 0)
14865                                                             {
14866                                                               if (((word >> 18) & 0x1) == 0)
14867                                                                 {
14868                                                                   if (((word >> 22) & 0x1) == 0)
14869                                                                     {
14870                                                                       /* 33222222222211111111110000000000
14871                                                                          10987654321098765432109876543210
14872                                                                          011001x1x0001000101xxxxxxxxxxxxx
14873                                                                          fcvt.  */
14874                                                                       return 1416;
14875                                                                     }
14876                                                                   else
14877                                                                     {
14878                                                                       /* 33222222222211111111110000000000
14879                                                                          10987654321098765432109876543210
14880                                                                          011001x1x1001000101xxxxxxxxxxxxx
14881                                                                          fcvt.  */
14882                                                                       return 1418;
14883                                                                     }
14884                                                                 }
14885                                                               else
14886                                                                 {
14887                                                                   /* 33222222222211111111110000000000
14888                                                                      10987654321098765432109876543210
14889                                                                      011001x1xx001100101xxxxxxxxxxxxx
14890                                                                      frecpx.  */
14891                                                                   return 1476;
14892                                                                 }
14893                                                             }
14894                                                           else
14895                                                             {
14896                                                               if (((word >> 22) & 0x1) == 0)
14897                                                                 {
14898                                                                   if (((word >> 23) & 0x1) == 0)
14899                                                                     {
14900                                                                       /* 33222222222211111111110000000000
14901                                                                          10987654321098765432109876543210
14902                                                                          011001x100001x10101xxxxxxxxxxxxx
14903                                                                          fcvtx.  */
14904                                                                       return 2086;
14905                                                                     }
14906                                                                   else
14907                                                                     {
14908                                                                       /* 33222222222211111111110000000000
14909                                                                          10987654321098765432109876543210
14910                                                                          011001x110001x10101xxxxxxxxxxxxx
14911                                                                          bfcvt.  */
14912                                                                       return 2495;
14913                                                                     }
14914                                                                 }
14915                                                               else
14916                                                                 {
14917                                                                   /* 33222222222211111111110000000000
14918                                                                      10987654321098765432109876543210
14919                                                                      011001x1x1001x10101xxxxxxxxxxxxx
14920                                                                      fcvt.  */
14921                                                                   return 1420;
14922                                                                 }
14923                                                             }
14924                                                         }
14925                                                       else
14926                                                         {
14927                                                           if (((word >> 22) & 0x1) == 0)
14928                                                             {
14929                                                               if (((word >> 23) & 0x1) == 0)
14930                                                                 {
14931                                                                   /* 33222222222211111111110000000000
14932                                                                      10987654321098765432109876543210
14933                                                                      011001x100011xx0101xxxxxxxxxxxxx
14934                                                                      flogb.  */
14935                                                                   return 2088;
14936                                                                 }
14937                                                               else
14938                                                                 {
14939                                                                   /* 33222222222211111111110000000000
14940                                                                      10987654321098765432109876543210
14941                                                                      011001x110011xx0101xxxxxxxxxxxxx
14942                                                                      fcvtzs.  */
14943                                                                   return 1425;
14944                                                                 }
14945                                                             }
14946                                                           else
14947                                                             {
14948                                                               if (((word >> 17) & 0x1) == 0)
14949                                                                 {
14950                                                                   if (((word >> 18) & 0x1) == 0)
14951                                                                     {
14952                                                                       /* 33222222222211111111110000000000
14953                                                                          10987654321098765432109876543210
14954                                                                          011001x1x1011000101xxxxxxxxxxxxx
14955                                                                          fcvtzs.  */
14956                                                                       return 1426;
14957                                                                     }
14958                                                                   else
14959                                                                     {
14960                                                                       if (((word >> 23) & 0x1) == 0)
14961                                                                         {
14962                                                                           /* 33222222222211111111110000000000
14963                                                                              10987654321098765432109876543210
14964                                                                              011001x101011100101xxxxxxxxxxxxx
14965                                                                              fcvtzs.  */
14966                                                                           return 1423;
14967                                                                         }
14968                                                                       else
14969                                                                         {
14970                                                                           /* 33222222222211111111110000000000
14971                                                                              10987654321098765432109876543210
14972                                                                              011001x111011100101xxxxxxxxxxxxx
14973                                                                              fcvtzs.  */
14974                                                                           return 1427;
14975                                                                         }
14976                                                                     }
14977                                                                 }
14978                                                               else
14979                                                                 {
14980                                                                   if (((word >> 18) & 0x1) == 0)
14981                                                                     {
14982                                                                       /* 33222222222211111111110000000000
14983                                                                          10987654321098765432109876543210
14984                                                                          011001x1x1011010101xxxxxxxxxxxxx
14985                                                                          fcvtzs.  */
14986                                                                       return 1422;
14987                                                                     }
14988                                                                   else
14989                                                                     {
14990                                                                       if (((word >> 23) & 0x1) == 0)
14991                                                                         {
14992                                                                           /* 33222222222211111111110000000000
14993                                                                              10987654321098765432109876543210
14994                                                                              011001x101011110101xxxxxxxxxxxxx
14995                                                                              fcvtzs.  */
14996                                                                           return 1424;
14997                                                                         }
14998                                                                       else
14999                                                                         {
15000                                                                           /* 33222222222211111111110000000000
15001                                                                              10987654321098765432109876543210
15002                                                                              011001x111011110101xxxxxxxxxxxxx
15003                                                                              fcvtzs.  */
15004                                                                           return 1428;
15005                                                                         }
15006                                                                     }
15007                                                                 }
15008                                                             }
15009                                                         }
15010                                                     }
15011                                                 }
15012                                               else
15013                                                 {
15014                                                   if (((word >> 17) & 0x1) == 0)
15015                                                     {
15016                                                       if (((word >> 18) & 0x1) == 0)
15017                                                         {
15018                                                           if (((word >> 19) & 0x1) == 0)
15019                                                             {
15020                                                               if (((word >> 20) & 0x1) == 0)
15021                                                                 {
15022                                                                   /* 33222222222211111111110000000000
15023                                                                      10987654321098765432109876543210
15024                                                                      011001x1xx000001101xxxxxxxxxxxxx
15025                                                                      frintp.  */
15026                                                                   return 1481;
15027                                                                 }
15028                                                               else
15029                                                                 {
15030                                                                   /* 33222222222211111111110000000000
15031                                                                      10987654321098765432109876543210
15032                                                                      011001x1xx010001101xxxxxxxxxxxxx
15033                                                                      ucvtf.  */
15034                                                                   return 1978;
15035                                                                 }
15036                                                             }
15037                                                           else
15038                                                             {
15039                                                               if (((word >> 20) & 0x1) == 0)
15040                                                                 {
15041                                                                   if (((word >> 22) & 0x1) == 0)
15042                                                                     {
15043                                                                       /* 33222222222211111111110000000000
15044                                                                          10987654321098765432109876543210
15045                                                                          011001x1x0001001101xxxxxxxxxxxxx
15046                                                                          fcvt.  */
15047                                                                       return 1417;
15048                                                                     }
15049                                                                   else
15050                                                                     {
15051                                                                       /* 33222222222211111111110000000000
15052                                                                          10987654321098765432109876543210
15053                                                                          011001x1x1001001101xxxxxxxxxxxxx
15054                                                                          fcvt.  */
15055                                                                       return 1419;
15056                                                                     }
15057                                                                 }
15058                                                               else
15059                                                                 {
15060                                                                   /* 33222222222211111111110000000000
15061                                                                      10987654321098765432109876543210
15062                                                                      011001x1xx011001101xxxxxxxxxxxxx
15063                                                                      fcvtzu.  */
15064                                                                   return 1433;
15065                                                                 }
15066                                                             }
15067                                                         }
15068                                                       else
15069                                                         {
15070                                                           if (((word >> 19) & 0x1) == 0)
15071                                                             {
15072                                                               if (((word >> 22) & 0x1) == 0)
15073                                                                 {
15074                                                                   /* 33222222222211111111110000000000
15075                                                                      10987654321098765432109876543210
15076                                                                      011001x1x00x0101101xxxxxxxxxxxxx
15077                                                                      ucvtf.  */
15078                                                                   return 1977;
15079                                                                 }
15080                                                               else
15081                                                                 {
15082                                                                   if (((word >> 23) & 0x1) == 0)
15083                                                                     {
15084                                                                       /* 33222222222211111111110000000000
15085                                                                          10987654321098765432109876543210
15086                                                                          011001x1010x0101101xxxxxxxxxxxxx
15087                                                                          ucvtf.  */
15088                                                                       return 1976;
15089                                                                     }
15090                                                                   else
15091                                                                     {
15092                                                                       /* 33222222222211111111110000000000
15093                                                                          10987654321098765432109876543210
15094                                                                          011001x1110x0101101xxxxxxxxxxxxx
15095                                                                          ucvtf.  */
15096                                                                       return 1980;
15097                                                                     }
15098                                                                 }
15099                                                             }
15100                                                           else
15101                                                             {
15102                                                               if (((word >> 20) & 0x1) == 0)
15103                                                                 {
15104                                                                   /* 33222222222211111111110000000000
15105                                                                      10987654321098765432109876543210
15106                                                                      011001x1xx001101101xxxxxxxxxxxxx
15107                                                                      fsqrt.  */
15108                                                                   return 1487;
15109                                                                 }
15110                                                               else
15111                                                                 {
15112                                                                   if (((word >> 22) & 0x1) == 0)
15113                                                                     {
15114                                                                       /* 33222222222211111111110000000000
15115                                                                          10987654321098765432109876543210
15116                                                                          011001x1x0011101101xxxxxxxxxxxxx
15117                                                                          fcvtzu.  */
15118                                                                       return 1432;
15119                                                                     }
15120                                                                   else
15121                                                                     {
15122                                                                       if (((word >> 23) & 0x1) == 0)
15123                                                                         {
15124                                                                           /* 33222222222211111111110000000000
15125                                                                              10987654321098765432109876543210
15126                                                                              011001x101011101101xxxxxxxxxxxxx
15127                                                                              fcvtzu.  */
15128                                                                           return 1430;
15129                                                                         }
15130                                                                       else
15131                                                                         {
15132                                                                           /* 33222222222211111111110000000000
15133                                                                              10987654321098765432109876543210
15134                                                                              011001x111011101101xxxxxxxxxxxxx
15135                                                                              fcvtzu.  */
15136                                                                           return 1434;
15137                                                                         }
15138                                                                     }
15139                                                                 }
15140                                                             }
15141                                                         }
15142                                                     }
15143                                                   else
15144                                                     {
15145                                                       if (((word >> 18) & 0x1) == 0)
15146                                                         {
15147                                                           if (((word >> 19) & 0x1) == 0)
15148                                                             {
15149                                                               if (((word >> 20) & 0x1) == 0)
15150                                                                 {
15151                                                                   /* 33222222222211111111110000000000
15152                                                                      10987654321098765432109876543210
15153                                                                      011001x1xx000011101xxxxxxxxxxxxx
15154                                                                      frintz.  */
15155                                                                   return 1483;
15156                                                                 }
15157                                                               else
15158                                                                 {
15159                                                                   /* 33222222222211111111110000000000
15160                                                                      10987654321098765432109876543210
15161                                                                      011001x1xx010011101xxxxxxxxxxxxx
15162                                                                      ucvtf.  */
15163                                                                   return 1975;
15164                                                                 }
15165                                                             }
15166                                                           else
15167                                                             {
15168                                                               if (((word >> 20) & 0x1) == 0)
15169                                                                 {
15170                                                                   /* 33222222222211111111110000000000
15171                                                                      10987654321098765432109876543210
15172                                                                      011001x1xx001011101xxxxxxxxxxxxx
15173                                                                      fcvt.  */
15174                                                                   return 1421;
15175                                                                 }
15176                                                               else
15177                                                                 {
15178                                                                   /* 33222222222211111111110000000000
15179                                                                      10987654321098765432109876543210
15180                                                                      011001x1xx011011101xxxxxxxxxxxxx
15181                                                                      fcvtzu.  */
15182                                                                   return 1429;
15183                                                                 }
15184                                                             }
15185                                                         }
15186                                                       else
15187                                                         {
15188                                                           if (((word >> 19) & 0x1) == 0)
15189                                                             {
15190                                                               if (((word >> 20) & 0x1) == 0)
15191                                                                 {
15192                                                                   /* 33222222222211111111110000000000
15193                                                                      10987654321098765432109876543210
15194                                                                      011001x1xx000111101xxxxxxxxxxxxx
15195                                                                      frinti.  */
15196                                                                   return 1478;
15197                                                                 }
15198                                                               else
15199                                                                 {
15200                                                                   if (((word >> 23) & 0x1) == 0)
15201                                                                     {
15202                                                                       /* 33222222222211111111110000000000
15203                                                                          10987654321098765432109876543210
15204                                                                          011001x10x010111101xxxxxxxxxxxxx
15205                                                                          ucvtf.  */
15206                                                                       return 1979;
15207                                                                     }
15208                                                                   else
15209                                                                     {
15210                                                                       /* 33222222222211111111110000000000
15211                                                                          10987654321098765432109876543210
15212                                                                          011001x11x010111101xxxxxxxxxxxxx
15213                                                                          ucvtf.  */
15214                                                                       return 1981;
15215                                                                     }
15216                                                                 }
15217                                                             }
15218                                                           else
15219                                                             {
15220                                                               if (((word >> 23) & 0x1) == 0)
15221                                                                 {
15222                                                                   /* 33222222222211111111110000000000
15223                                                                      10987654321098765432109876543210
15224                                                                      011001x10x0x1111101xxxxxxxxxxxxx
15225                                                                      fcvtzu.  */
15226                                                                   return 1431;
15227                                                                 }
15228                                                               else
15229                                                                 {
15230                                                                   /* 33222222222211111111110000000000
15231                                                                      10987654321098765432109876543210
15232                                                                      011001x11x0x1111101xxxxxxxxxxxxx
15233                                                                      fcvtzu.  */
15234                                                                   return 1435;
15235                                                                 }
15236                                                             }
15237                                                         }
15238                                                     }
15239                                                 }
15240                                             }
15241                                           else
15242                                             {
15243                                               if (((word >> 22) & 0x1) == 0)
15244                                                 {
15245                                                   if (((word >> 23) & 0x1) == 0)
15246                                                     {
15247                                                       /* 33222222222211111111110000000000
15248                                                          10987654321098765432109876543210
15249                                                          111001x1000xxxxx101xxxxxxxxxxxxx
15250                                                          st1w.  */
15251                                                       return 1913;
15252                                                     }
15253                                                   else
15254                                                     {
15255                                                       /* 33222222222211111111110000000000
15256                                                          10987654321098765432109876543210
15257                                                          111001x1100xxxxx101xxxxxxxxxxxxx
15258                                                          st1d.  */
15259                                                       return 1892;
15260                                                     }
15261                                                 }
15262                                               else
15263                                                 {
15264                                                   if (((word >> 23) & 0x1) == 0)
15265                                                     {
15266                                                       /* 33222222222211111111110000000000
15267                                                          10987654321098765432109876543210
15268                                                          111001x1010xxxxx101xxxxxxxxxxxxx
15269                                                          st1w.  */
15270                                                       return 1920;
15271                                                     }
15272                                                   else
15273                                                     {
15274                                                       /* 33222222222211111111110000000000
15275                                                          10987654321098765432109876543210
15276                                                          111001x1110xxxxx101xxxxxxxxxxxxx
15277                                                          st1d.  */
15278                                                       return 1896;
15279                                                     }
15280                                                 }
15281                                             }
15282                                         }
15283                                       else
15284                                         {
15285                                           if (((word >> 31) & 0x1) == 0)
15286                                             {
15287                                               /* 33222222222211111111110000000000
15288                                                  10987654321098765432109876543210
15289                                                  011001x1xx0xxxxx111xxxxxxxxxxxxx
15290                                                  facgt.  */
15291                                               return 1394;
15292                                             }
15293                                           else
15294                                             {
15295                                               if (((word >> 20) & 0x1) == 0)
15296                                                 {
15297                                                   /* 33222222222211111111110000000000
15298                                                      10987654321098765432109876543210
15299                                                      111001x1xx00xxxx111xxxxxxxxxxxxx
15300                                                      st1w.  */
15301                                                   return 1921;
15302                                                 }
15303                                               else
15304                                                 {
15305                                                   if (((word >> 22) & 0x1) == 0)
15306                                                     {
15307                                                       if (((word >> 23) & 0x1) == 0)
15308                                                         {
15309                                                           /* 33222222222211111111110000000000
15310                                                              10987654321098765432109876543210
15311                                                              111001x10001xxxx111xxxxxxxxxxxxx
15312                                                              stnt1w.  */
15313                                                           return 1955;
15314                                                         }
15315                                                       else
15316                                                         {
15317                                                           /* 33222222222211111111110000000000
15318                                                              10987654321098765432109876543210
15319                                                              111001x11001xxxx111xxxxxxxxxxxxx
15320                                                              stnt1d.  */
15321                                                           return 1951;
15322                                                         }
15323                                                     }
15324                                                   else
15325                                                     {
15326                                                       if (((word >> 23) & 0x1) == 0)
15327                                                         {
15328                                                           /* 33222222222211111111110000000000
15329                                                              10987654321098765432109876543210
15330                                                              111001x10101xxxx111xxxxxxxxxxxxx
15331                                                              st3w.  */
15332                                                           return 1939;
15333                                                         }
15334                                                       else
15335                                                         {
15336                                                           /* 33222222222211111111110000000000
15337                                                              10987654321098765432109876543210
15338                                                              111001x11101xxxx111xxxxxxxxxxxxx
15339                                                              st3d.  */
15340                                                           return 1935;
15341                                                         }
15342                                                     }
15343                                                 }
15344                                             }
15345                                         }
15346                                     }
15347                                 }
15348                             }
15349                           else
15350                             {
15351                               if (((word >> 30) & 0x1) == 0)
15352                                 {
15353                                   if (((word >> 14) & 0x1) == 0)
15354                                     {
15355                                       if (((word >> 20) & 0x1) == 0)
15356                                         {
15357                                           if (((word >> 31) & 0x1) == 0)
15358                                             {
15359                                               if (((word >> 16) & 0x1) == 0)
15360                                                 {
15361                                                   if (((word >> 17) & 0x1) == 0)
15362                                                     {
15363                                                       if (((word >> 18) & 0x1) == 0)
15364                                                         {
15365                                                           if (((word >> 19) & 0x1) == 0)
15366                                                             {
15367                                                               /* 33222222222211111111110000000000
15368                                                                  10987654321098765432109876543210
15369                                                                  001001x1xx10000010xxxxxxxxxxxxxx
15370                                                                  cntp.  */
15371                                                               return 1363;
15372                                                             }
15373                                                           else
15374                                                             {
15375                                                               if (((word >> 10) & 0x1) == 0)
15376                                                                 {
15377                                                                   if (((word >> 11) & 0x1) == 0)
15378                                                                     {
15379                                                                       if (((word >> 12) & 0x1) == 0)
15380                                                                         {
15381                                                                           /* 33222222222211111111110000000000
15382                                                                              10987654321098765432109876543210
15383                                                                              001001x1xx10100010x000xxxxxxxxxx
15384                                                                              sqincp.  */
15385                                                                           return 1870;
15386                                                                         }
15387                                                                       else
15388                                                                         {
15389                                                                           /* 33222222222211111111110000000000
15390                                                                              10987654321098765432109876543210
15391                                                                              001001x1xx10100010x100xxxxxxxxxx
15392                                                                              wrffr.  */
15393                                                                           return 2043;
15394                                                                         }
15395                                                                     }
15396                                                                   else
15397                                                                     {
15398                                                                       /* 33222222222211111111110000000000
15399                                                                          10987654321098765432109876543210
15400                                                                          001001x1xx10100010xx10xxxxxxxxxx
15401                                                                          sqincp.  */
15402                                                                       return 1872;
15403                                                                     }
15404                                                                 }
15405                                                               else
15406                                                                 {
15407                                                                   /* 33222222222211111111110000000000
15408                                                                      10987654321098765432109876543210
15409                                                                      001001x1xx10100010xxx1xxxxxxxxxx
15410                                                                      sqincp.  */
15411                                                                   return 1871;
15412                                                                 }
15413                                                             }
15414                                                         }
15415                                                       else
15416                                                         {
15417                                                           if (((word >> 11) & 0x1) == 0)
15418                                                             {
15419                                                               if (((word >> 12) & 0x1) == 0)
15420                                                                 {
15421                                                                   /* 33222222222211111111110000000000
15422                                                                      10987654321098765432109876543210
15423                                                                      001001x1xx10x10010x00xxxxxxxxxxx
15424                                                                      incp.  */
15425                                                                   return 1501;
15426                                                                 }
15427                                                               else
15428                                                                 {
15429                                                                   /* 33222222222211111111110000000000
15430                                                                      10987654321098765432109876543210
15431                                                                      001001x1xx10x10010x10xxxxxxxxxxx
15432                                                                      setffr.  */
15433                                                                   return 1837;
15434                                                                 }
15435                                                             }
15436                                                           else
15437                                                             {
15438                                                               /* 33222222222211111111110000000000
15439                                                                  10987654321098765432109876543210
15440                                                                  001001x1xx10x10010xx1xxxxxxxxxxx
15441                                                                  incp.  */
15442                                                               return 1502;
15443                                                             }
15444                                                         }
15445                                                     }
15446                                                   else
15447                                                     {
15448                                                       if (((word >> 10) & 0x1) == 0)
15449                                                         {
15450                                                           if (((word >> 11) & 0x1) == 0)
15451                                                             {
15452                                                               /* 33222222222211111111110000000000
15453                                                                  10987654321098765432109876543210
15454                                                                  001001x1xx10xx1010xx00xxxxxxxxxx
15455                                                                  sqdecp.  */
15456                                                               return 1856;
15457                                                             }
15458                                                           else
15459                                                             {
15460                                                               /* 33222222222211111111110000000000
15461                                                                  10987654321098765432109876543210
15462                                                                  001001x1xx10xx1010xx10xxxxxxxxxx
15463                                                                  sqdecp.  */
15464                                                               return 1858;
15465                                                             }
15466                                                         }
15467                                                       else
15468                                                         {
15469                                                           /* 33222222222211111111110000000000
15470                                                              10987654321098765432109876543210
15471                                                              001001x1xx10xx1010xxx1xxxxxxxxxx
15472                                                              sqdecp.  */
15473                                                           return 1857;
15474                                                         }
15475                                                     }
15476                                                 }
15477                                               else
15478                                                 {
15479                                                   if (((word >> 10) & 0x1) == 0)
15480                                                     {
15481                                                       if (((word >> 11) & 0x1) == 0)
15482                                                         {
15483                                                           if (((word >> 17) & 0x1) == 0)
15484                                                             {
15485                                                               if (((word >> 18) & 0x1) == 0)
15486                                                                 {
15487                                                                   /* 33222222222211111111110000000000
15488                                                                      10987654321098765432109876543210
15489                                                                      001001x1xx10x00110xx00xxxxxxxxxx
15490                                                                      uqincp.  */
15491                                                                   return 2018;
15492                                                                 }
15493                                                               else
15494                                                                 {
15495                                                                   /* 33222222222211111111110000000000
15496                                                                      10987654321098765432109876543210
15497                                                                      001001x1xx10x10110xx00xxxxxxxxxx
15498                                                                      decp.  */
15499                                                                   return 1376;
15500                                                                 }
15501                                                             }
15502                                                           else
15503                                                             {
15504                                                               /* 33222222222211111111110000000000
15505                                                                  10987654321098765432109876543210
15506                                                                  001001x1xx10xx1110xx00xxxxxxxxxx
15507                                                                  uqdecp.  */
15508                                                               return 2004;
15509                                                             }
15510                                                         }
15511                                                       else
15512                                                         {
15513                                                           if (((word >> 17) & 0x1) == 0)
15514                                                             {
15515                                                               if (((word >> 18) & 0x1) == 0)
15516                                                                 {
15517                                                                   /* 33222222222211111111110000000000
15518                                                                      10987654321098765432109876543210
15519                                                                      001001x1xx10x00110xx10xxxxxxxxxx
15520                                                                      uqincp.  */
15521                                                                   return 2019;
15522                                                                 }
15523                                                               else
15524                                                                 {
15525                                                                   /* 33222222222211111111110000000000
15526                                                                      10987654321098765432109876543210
15527                                                                      001001x1xx10x10110xx10xxxxxxxxxx
15528                                                                      decp.  */
15529                                                                   return 1377;
15530                                                                 }
15531                                                             }
15532                                                           else
15533                                                             {
15534                                                               /* 33222222222211111111110000000000
15535                                                                  10987654321098765432109876543210
15536                                                                  001001x1xx10xx1110xx10xxxxxxxxxx
15537                                                                  uqdecp.  */
15538                                                               return 2005;
15539                                                             }
15540                                                         }
15541                                                     }
15542                                                   else
15543                                                     {
15544                                                       if (((word >> 17) & 0x1) == 0)
15545                                                         {
15546                                                           /* 33222222222211111111110000000000
15547                                                              10987654321098765432109876543210
15548                                                              001001x1xx10xx0110xxx1xxxxxxxxxx
15549                                                              uqincp.  */
15550                                                           return 2020;
15551                                                         }
15552                                                       else
15553                                                         {
15554                                                           /* 33222222222211111111110000000000
15555                                                              10987654321098765432109876543210
15556                                                              001001x1xx10xx1110xxx1xxxxxxxxxx
15557                                                              uqdecp.  */
15558                                                           return 2006;
15559                                                         }
15560                                                     }
15561                                                 }
15562                                             }
15563                                           else
15564                                             {
15565                                               if (((word >> 22) & 0x1) == 0)
15566                                                 {
15567                                                   if (((word >> 23) & 0x1) == 0)
15568                                                     {
15569                                                       /* 33222222222211111111110000000000
15570                                                          10987654321098765432109876543210
15571                                                          101001x10010xxxx10xxxxxxxxxxxxxx
15572                                                          ld1sh.  */
15573                                                       return 1594;
15574                                                     }
15575                                                   else
15576                                                     {
15577                                                       /* 33222222222211111111110000000000
15578                                                          10987654321098765432109876543210
15579                                                          101001x11010xxxx10xxxxxxxxxxxxxx
15580                                                          ld1sb.  */
15581                                                       return 1581;
15582                                                     }
15583                                                 }
15584                                               else
15585                                                 {
15586                                                   if (((word >> 23) & 0x1) == 0)
15587                                                     {
15588                                                       /* 33222222222211111111110000000000
15589                                                          10987654321098765432109876543210
15590                                                          101001x10110xxxx10xxxxxxxxxxxxxx
15591                                                          ld1w.  */
15592                                                       return 1613;
15593                                                     }
15594                                                   else
15595                                                     {
15596                                                       /* 33222222222211111111110000000000
15597                                                          10987654321098765432109876543210
15598                                                          101001x11110xxxx10xxxxxxxxxxxxxx
15599                                                          ld1d.  */
15600                                                       return 1533;
15601                                                     }
15602                                                 }
15603                                             }
15604                                         }
15605                                       else
15606                                         {
15607                                           if (((word >> 22) & 0x1) == 0)
15608                                             {
15609                                               if (((word >> 23) & 0x1) == 0)
15610                                                 {
15611                                                   /* 33222222222211111111110000000000
15612                                                      10987654321098765432109876543210
15613                                                      x01001x10011xxxx10xxxxxxxxxxxxxx
15614                                                      ldnf1sh.  */
15615                                                   return 1727;
15616                                                 }
15617                                               else
15618                                                 {
15619                                                   /* 33222222222211111111110000000000
15620                                                      10987654321098765432109876543210
15621                                                      x01001x11011xxxx10xxxxxxxxxxxxxx
15622                                                      ldnf1sb.  */
15623                                                   return 1724;
15624                                                 }
15625                                             }
15626                                           else
15627                                             {
15628                                               if (((word >> 23) & 0x1) == 0)
15629                                                 {
15630                                                   /* 33222222222211111111110000000000
15631                                                      10987654321098765432109876543210
15632                                                      x01001x10111xxxx10xxxxxxxxxxxxxx
15633                                                      ldnf1w.  */
15634                                                   return 1730;
15635                                                 }
15636                                               else
15637                                                 {
15638                                                   /* 33222222222211111111110000000000
15639                                                      10987654321098765432109876543210
15640                                                      x01001x11111xxxx10xxxxxxxxxxxxxx
15641                                                      ldnf1d.  */
15642                                                   return 1719;
15643                                                 }
15644                                             }
15645                                         }
15646                                     }
15647                                   else
15648                                     {
15649                                       if (((word >> 31) & 0x1) == 0)
15650                                         {
15651                                           if (((word >> 16) & 0x1) == 0)
15652                                             {
15653                                               if (((word >> 17) & 0x1) == 0)
15654                                                 {
15655                                                   if (((word >> 18) & 0x1) == 0)
15656                                                     {
15657                                                       if (((word >> 19) & 0x1) == 0)
15658                                                         {
15659                                                           if (((word >> 20) & 0x1) == 0)
15660                                                             {
15661                                                               /* 33222222222211111111110000000000
15662                                                                  10987654321098765432109876543210
15663                                                                  001001x1xx10000011xxxxxxxxxxxxxx
15664                                                                  add.  */
15665                                                               return 1290;
15666                                                             }
15667                                                           else
15668                                                             {
15669                                                               /* 33222222222211111111110000000000
15670                                                                  10987654321098765432109876543210
15671                                                                  001001x1xx11000011xxxxxxxxxxxxxx
15672                                                                  mul.  */
15673                                                               return 1759;
15674                                                             }
15675                                                         }
15676                                                       else
15677                                                         {
15678                                                           if (((word >> 20) & 0x1) == 0)
15679                                                             {
15680                                                               /* 33222222222211111111110000000000
15681                                                                  10987654321098765432109876543210
15682                                                                  001001x1xx10100011xxxxxxxxxxxxxx
15683                                                                  smax.  */
15684                                                               return 1838;
15685                                                             }
15686                                                           else
15687                                                             {
15688                                                               /* 33222222222211111111110000000000
15689                                                                  10987654321098765432109876543210
15690                                                                  001001x1xx11100011xxxxxxxxxxxxxx
15691                                                                  dup.  */
15692                                                               return 1382;
15693                                                             }
15694                                                         }
15695                                                     }
15696                                                   else
15697                                                     {
15698                                                       /* 33222222222211111111110000000000
15699                                                          10987654321098765432109876543210
15700                                                          001001x1xx1xx10011xxxxxxxxxxxxxx
15701                                                          sqadd.  */
15702                                                       return 1847;
15703                                                     }
15704                                                 }
15705                                               else
15706                                                 {
15707                                                   if (((word >> 18) & 0x1) == 0)
15708                                                     {
15709                                                       /* 33222222222211111111110000000000
15710                                                          10987654321098765432109876543210
15711                                                          001001x1xx1xx01011xxxxxxxxxxxxxx
15712                                                          smin.  */
15713                                                       return 1841;
15714                                                     }
15715                                                   else
15716                                                     {
15717                                                       /* 33222222222211111111110000000000
15718                                                          10987654321098765432109876543210
15719                                                          001001x1xx1xx11011xxxxxxxxxxxxxx
15720                                                          sqsub.  */
15721                                                       return 1877;
15722                                                     }
15723                                                 }
15724                                             }
15725                                           else
15726                                             {
15727                                               if (((word >> 17) & 0x1) == 0)
15728                                                 {
15729                                                   if (((word >> 18) & 0x1) == 0)
15730                                                     {
15731                                                       if (((word >> 19) & 0x1) == 0)
15732                                                         {
15733                                                           /* 33222222222211111111110000000000
15734                                                              10987654321098765432109876543210
15735                                                              001001x1xx1x000111xxxxxxxxxxxxxx
15736                                                              sub.  */
15737                                                           return 1959;
15738                                                         }
15739                                                       else
15740                                                         {
15741                                                           if (((word >> 20) & 0x1) == 0)
15742                                                             {
15743                                                               /* 33222222222211111111110000000000
15744                                                                  10987654321098765432109876543210
15745                                                                  001001x1xx10100111xxxxxxxxxxxxxx
15746                                                                  umax.  */
15747                                                               return 1987;
15748                                                             }
15749                                                           else
15750                                                             {
15751                                                               /* 33222222222211111111110000000000
15752                                                                  10987654321098765432109876543210
15753                                                                  001001x1xx11100111xxxxxxxxxxxxxx
15754                                                                  fdup.  */
15755                                                               return 1438;
15756                                                             }
15757                                                         }
15758                                                     }
15759                                                   else
15760                                                     {
15761                                                       /* 33222222222211111111110000000000
15762                                                          10987654321098765432109876543210
15763                                                          001001x1xx1xx10111xxxxxxxxxxxxxx
15764                                                          uqadd.  */
15765                                                       return 1995;
15766                                                     }
15767                                                 }
15768                                               else
15769                                                 {
15770                                                   if (((word >> 18) & 0x1) == 0)
15771                                                     {
15772                                                       if (((word >> 19) & 0x1) == 0)
15773                                                         {
15774                                                           /* 33222222222211111111110000000000
15775                                                              10987654321098765432109876543210
15776                                                              001001x1xx1x001111xxxxxxxxxxxxxx
15777                                                              subr.  */
15778                                                           return 1961;
15779                                                         }
15780                                                       else
15781                                                         {
15782                                                           /* 33222222222211111111110000000000
15783                                                              10987654321098765432109876543210
15784                                                              001001x1xx1x101111xxxxxxxxxxxxxx
15785                                                              umin.  */
15786                                                           return 1990;
15787                                                         }
15788                                                     }
15789                                                   else
15790                                                     {
15791                                                       /* 33222222222211111111110000000000
15792                                                          10987654321098765432109876543210
15793                                                          001001x1xx1xx11111xxxxxxxxxxxxxx
15794                                                          uqsub.  */
15795                                                       return 2025;
15796                                                     }
15797                                                 }
15798                                             }
15799                                         }
15800                                       else
15801                                         {
15802                                           if (((word >> 13) & 0x1) == 0)
15803                                             {
15804                                               if (((word >> 22) & 0x1) == 0)
15805                                                 {
15806                                                   if (((word >> 23) & 0x1) == 0)
15807                                                     {
15808                                                       /* 33222222222211111111110000000000
15809                                                          10987654321098765432109876543210
15810                                                          101001x1001xxxxx110xxxxxxxxxxxxx
15811                                                          ld2w.  */
15812                                                       return 1621;
15813                                                     }
15814                                                   else
15815                                                     {
15816                                                       /* 33222222222211111111110000000000
15817                                                          10987654321098765432109876543210
15818                                                          101001x1101xxxxx110xxxxxxxxxxxxx
15819                                                          ld2d.  */
15820                                                       return 1617;
15821                                                     }
15822                                                 }
15823                                               else
15824                                                 {
15825                                                   if (((word >> 23) & 0x1) == 0)
15826                                                     {
15827                                                       /* 33222222222211111111110000000000
15828                                                          10987654321098765432109876543210
15829                                                          101001x1011xxxxx110xxxxxxxxxxxxx
15830                                                          ld4w.  */
15831                                                       return 1637;
15832                                                     }
15833                                                   else
15834                                                     {
15835                                                       /* 33222222222211111111110000000000
15836                                                          10987654321098765432109876543210
15837                                                          101001x1111xxxxx110xxxxxxxxxxxxx
15838                                                          ld4d.  */
15839                                                       return 1633;
15840                                                     }
15841                                                 }
15842                                             }
15843                                           else
15844                                             {
15845                                               if (((word >> 22) & 0x1) == 0)
15846                                                 {
15847                                                   if (((word >> 23) & 0x1) == 0)
15848                                                     {
15849                                                       /* 33222222222211111111110000000000
15850                                                          10987654321098765432109876543210
15851                                                          101001x1001xxxxx111xxxxxxxxxxxxx
15852                                                          ld2w.  */
15853                                                       return 1622;
15854                                                     }
15855                                                   else
15856                                                     {
15857                                                       /* 33222222222211111111110000000000
15858                                                          10987654321098765432109876543210
15859                                                          101001x1101xxxxx111xxxxxxxxxxxxx
15860                                                          ld2d.  */
15861                                                       return 1618;
15862                                                     }
15863                                                 }
15864                                               else
15865                                                 {
15866                                                   if (((word >> 23) & 0x1) == 0)
15867                                                     {
15868                                                       /* 33222222222211111111110000000000
15869                                                          10987654321098765432109876543210
15870                                                          101001x1011xxxxx111xxxxxxxxxxxxx
15871                                                          ld4w.  */
15872                                                       return 1638;
15873                                                     }
15874                                                   else
15875                                                     {
15876                                                       /* 33222222222211111111110000000000
15877                                                          10987654321098765432109876543210
15878                                                          101001x1111xxxxx111xxxxxxxxxxxxx
15879                                                          ld4d.  */
15880                                                       return 1634;
15881                                                     }
15882                                                 }
15883                                             }
15884                                         }
15885                                     }
15886                                 }
15887                               else
15888                                 {
15889                                   if (((word >> 13) & 0x1) == 0)
15890                                     {
15891                                       if (((word >> 31) & 0x1) == 0)
15892                                         {
15893                                           if (((word >> 14) & 0x1) == 0)
15894                                             {
15895                                               /* 33222222222211111111110000000000
15896                                                  10987654321098765432109876543210
15897                                                  011001x1xx1xxxxx100xxxxxxxxxxxxx
15898                                                  fmad.  */
15899                                               return 1440;
15900                                             }
15901                                           else
15902                                             {
15903                                               /* 33222222222211111111110000000000
15904                                                  10987654321098765432109876543210
15905                                                  011001x1xx1xxxxx110xxxxxxxxxxxxx
15906                                                  fnmad.  */
15907                                               return 1470;
15908                                             }
15909                                         }
15910                                       else
15911                                         {
15912                                           if (((word >> 22) & 0x1) == 0)
15913                                             {
15914                                               if (((word >> 23) & 0x1) == 0)
15915                                                 {
15916                                                   /* 33222222222211111111110000000000
15917                                                      10987654321098765432109876543210
15918                                                      111001x1001xxxxx1x0xxxxxxxxxxxxx
15919                                                      st1w.  */
15920                                                   return 1914;
15921                                                 }
15922                                               else
15923                                                 {
15924                                                   /* 33222222222211111111110000000000
15925                                                      10987654321098765432109876543210
15926                                                      111001x1101xxxxx1x0xxxxxxxxxxxxx
15927                                                      st1d.  */
15928                                                   return 1893;
15929                                                 }
15930                                             }
15931                                           else
15932                                             {
15933                                               /* 33222222222211111111110000000000
15934                                                  10987654321098765432109876543210
15935                                                  111001x1x11xxxxx1x0xxxxxxxxxxxxx
15936                                                  st1w.  */
15937                                               return 1919;
15938                                             }
15939                                         }
15940                                     }
15941                                   else
15942                                     {
15943                                       if (((word >> 14) & 0x1) == 0)
15944                                         {
15945                                           if (((word >> 31) & 0x1) == 0)
15946                                             {
15947                                               /* 33222222222211111111110000000000
15948                                                  10987654321098765432109876543210
15949                                                  011001x1xx1xxxxx101xxxxxxxxxxxxx
15950                                                  fmsb.  */
15951                                               return 1461;
15952                                             }
15953                                           else
15954                                             {
15955                                               if (((word >> 22) & 0x1) == 0)
15956                                                 {
15957                                                   if (((word >> 23) & 0x1) == 0)
15958                                                     {
15959                                                       /* 33222222222211111111110000000000
15960                                                          10987654321098765432109876543210
15961                                                          111001x1001xxxxx101xxxxxxxxxxxxx
15962                                                          st1w.  */
15963                                                       return 1915;
15964                                                     }
15965                                                   else
15966                                                     {
15967                                                       /* 33222222222211111111110000000000
15968                                                          10987654321098765432109876543210
15969                                                          111001x1101xxxxx101xxxxxxxxxxxxx
15970                                                          st1d.  */
15971                                                       return 1894;
15972                                                     }
15973                                                 }
15974                                               else
15975                                                 {
15976                                                   /* 33222222222211111111110000000000
15977                                                      10987654321098765432109876543210
15978                                                      111001x1x11xxxxx101xxxxxxxxxxxxx
15979                                                      st1w.  */
15980                                                   return 1922;
15981                                                 }
15982                                             }
15983                                         }
15984                                       else
15985                                         {
15986                                           if (((word >> 31) & 0x1) == 0)
15987                                             {
15988                                               /* 33222222222211111111110000000000
15989                                                  10987654321098765432109876543210
15990                                                  011001x1xx1xxxxx111xxxxxxxxxxxxx
15991                                                  fnmsb.  */
15992                                               return 1473;
15993                                             }
15994                                           else
15995                                             {
15996                                               if (((word >> 20) & 0x1) == 0)
15997                                                 {
15998                                                   if (((word >> 23) & 0x1) == 0)
15999                                                     {
16000                                                       /* 33222222222211111111110000000000
16001                                                          10987654321098765432109876543210
16002                                                          111001x10x10xxxx111xxxxxxxxxxxxx
16003                                                          st1w.  */
16004                                                       return 1923;
16005                                                     }
16006                                                   else
16007                                                     {
16008                                                       /* 33222222222211111111110000000000
16009                                                          10987654321098765432109876543210
16010                                                          111001x11x10xxxx111xxxxxxxxxxxxx
16011                                                          st1d.  */
16012                                                       return 1897;
16013                                                     }
16014                                                 }
16015                                               else
16016                                                 {
16017                                                   if (((word >> 22) & 0x1) == 0)
16018                                                     {
16019                                                       if (((word >> 23) & 0x1) == 0)
16020                                                         {
16021                                                           /* 33222222222211111111110000000000
16022                                                              10987654321098765432109876543210
16023                                                              111001x10011xxxx111xxxxxxxxxxxxx
16024                                                              st2w.  */
16025                                                           return 1931;
16026                                                         }
16027                                                       else
16028                                                         {
16029                                                           /* 33222222222211111111110000000000
16030                                                              10987654321098765432109876543210
16031                                                              111001x11011xxxx111xxxxxxxxxxxxx
16032                                                              st2d.  */
16033                                                           return 1927;
16034                                                         }
16035                                                     }
16036                                                   else
16037                                                     {
16038                                                       if (((word >> 23) & 0x1) == 0)
16039                                                         {
16040                                                           /* 33222222222211111111110000000000
16041                                                              10987654321098765432109876543210
16042                                                              111001x10111xxxx111xxxxxxxxxxxxx
16043                                                              st4w.  */
16044                                                           return 1947;
16045                                                         }
16046                                                       else
16047                                                         {
16048                                                           /* 33222222222211111111110000000000
16049                                                              10987654321098765432109876543210
16050                                                              111001x11111xxxx111xxxxxxxxxxxxx
16051                                                              st4d.  */
16052                                                           return 1943;
16053                                                         }
16054                                                     }
16055                                                 }
16056                                             }
16057                                         }
16058                                     }
16059                                 }
16060                             }
16061                         }
16062                     }
16063                 }
16064             }
16065           else
16066             {
16067               if (((word >> 29) & 0x1) == 0)
16068                 {
16069                   if (((word >> 30) & 0x1) == 0)
16070                     {
16071                       if (((word >> 31) & 0x1) == 0)
16072                         {
16073                           /* 33222222222211111111110000000000
16074                              10987654321098765432109876543210
16075                              000101xxxxxxxxxxxxxxxxxxxxxxxxxx
16076                              b.  */
16077                           return 636;
16078                         }
16079                       else
16080                         {
16081                           /* 33222222222211111111110000000000
16082                              10987654321098765432109876543210
16083                              100101xxxxxxxxxxxxxxxxxxxxxxxxxx
16084                              bl.  */
16085                           return 637;
16086                         }
16087                     }
16088                   else
16089                     {
16090                       if (((word >> 24) & 0x1) == 0)
16091                         {
16092                           if (((word >> 4) & 0x1) == 0)
16093                             {
16094                               if (((word >> 25) & 0x1) == 0)
16095                                 {
16096                                   if (((word >> 31) & 0x1) == 0)
16097                                     {
16098                                       /* 33222222222211111111110000000000
16099                                          10987654321098765432109876543210
16100                                          01010100xxxxxxxxxxxxxxxxxxx0xxxx
16101                                          b.c.  */
16102                                       return 657;
16103                                     }
16104                                   else
16105                                     {
16106                                       if (((word >> 0) & 0x1) == 0)
16107                                         {
16108                                           if (((word >> 1) & 0x1) == 0)
16109                                             {
16110                                               if (((word >> 21) & 0x1) == 0)
16111                                                 {
16112                                                   /* 33222222222211111111110000000000
16113                                                      10987654321098765432109876543210
16114                                                      11010100xx0xxxxxxxxxxxxxxxx0xx00
16115                                                      hlt.  */
16116                                                   return 753;
16117                                                 }
16118                                               else
16119                                                 {
16120                                                   if (((word >> 22) & 0x1) == 0)
16121                                                     {
16122                                                       /* 33222222222211111111110000000000
16123                                                          10987654321098765432109876543210
16124                                                          11010100x01xxxxxxxxxxxxxxxx0xx00
16125                                                          brk.  */
16126                                                       return 752;
16127                                                     }
16128                                                   else
16129                                                     {
16130                                                       /* 33222222222211111111110000000000
16131                                                          10987654321098765432109876543210
16132                                                          11010100x11xxxxxxxxxxxxxxxx0xx00
16133                                                          tcancel.  */
16134                                                       return 1196;
16135                                                     }
16136                                                 }
16137                                             }
16138                                           else
16139                                             {
16140                                               if (((word >> 21) & 0x1) == 0)
16141                                                 {
16142                                                   /* 33222222222211111111110000000000
16143                                                      10987654321098765432109876543210
16144                                                      11010100xx0xxxxxxxxxxxxxxxx0xx10
16145                                                      hvc.  */
16146                                                   return 750;
16147                                                 }
16148                                               else
16149                                                 {
16150                                                   /* 33222222222211111111110000000000
16151                                                      10987654321098765432109876543210
16152                                                      11010100xx1xxxxxxxxxxxxxxxx0xx10
16153                                                      dcps2.  */
16154                                                   return 756;
16155                                                 }
16156                                             }
16157                                         }
16158                                       else
16159                                         {
16160                                           if (((word >> 1) & 0x1) == 0)
16161                                             {
16162                                               if (((word >> 21) & 0x1) == 0)
16163                                                 {
16164                                                   /* 33222222222211111111110000000000
16165                                                      10987654321098765432109876543210
16166                                                      11010100xx0xxxxxxxxxxxxxxxx0xx01
16167                                                      svc.  */
16168                                                   return 749;
16169                                                 }
16170                                               else
16171                                                 {
16172                                                   /* 33222222222211111111110000000000
16173                                                      10987654321098765432109876543210
16174                                                      11010100xx1xxxxxxxxxxxxxxxx0xx01
16175                                                      dcps1.  */
16176                                                   return 755;
16177                                                 }
16178                                             }
16179                                           else
16180                                             {
16181                                               if (((word >> 21) & 0x1) == 0)
16182                                                 {
16183                                                   /* 33222222222211111111110000000000
16184                                                      10987654321098765432109876543210
16185                                                      11010100xx0xxxxxxxxxxxxxxxx0xx11
16186                                                      smc.  */
16187                                                   return 751;
16188                                                 }
16189                                               else
16190                                                 {
16191                                                   /* 33222222222211111111110000000000
16192                                                      10987654321098765432109876543210
16193                                                      11010100xx1xxxxxxxxxxxxxxxx0xx11
16194                                                      dcps3.  */
16195                                                   return 757;
16196                                                 }
16197                                             }
16198                                         }
16199                                     }
16200                                 }
16201                               else
16202                                 {
16203                                   if (((word >> 21) & 0x1) == 0)
16204                                     {
16205                                       if (((word >> 22) & 0x1) == 0)
16206                                         {
16207                                           if (((word >> 23) & 0x1) == 0)
16208                                             {
16209                                               /* 33222222222211111111110000000000
16210                                                  10987654321098765432109876543210
16211                                                  x1010110000xxxxxxxxxxxxxxxx0xxxx
16212                                                  br.  */
16213                                               return 638;
16214                                             }
16215                                           else
16216                                             {
16217                                               /* 33222222222211111111110000000000
16218                                                  10987654321098765432109876543210
16219                                                  x1010110100xxxxxxxxxxxxxxxx0xxxx
16220                                                  eret.  */
16221                                               return 641;
16222                                             }
16223                                         }
16224                                       else
16225                                         {
16226                                           /* 33222222222211111111110000000000
16227                                              10987654321098765432109876543210
16228                                              x1010110x10xxxxxxxxxxxxxxxx0xxxx
16229                                              ret.  */
16230                                           return 640;
16231                                         }
16232                                     }
16233                                   else
16234                                     {
16235                                       if (((word >> 23) & 0x1) == 0)
16236                                         {
16237                                           /* 33222222222211111111110000000000
16238                                              10987654321098765432109876543210
16239                                              x10101100x1xxxxxxxxxxxxxxxx0xxxx
16240                                              blr.  */
16241                                           return 639;
16242                                         }
16243                                       else
16244                                         {
16245                                           /* 33222222222211111111110000000000
16246                                              10987654321098765432109876543210
16247                                              x10101101x1xxxxxxxxxxxxxxxx0xxxx
16248                                              drps.  */
16249                                           return 642;
16250                                         }
16251                                     }
16252                                 }
16253                             }
16254                           else
16255                             {
16256                               if (((word >> 10) & 0x1) == 0)
16257                                 {
16258                                   if (((word >> 21) & 0x1) == 0)
16259                                     {
16260                                       if (((word >> 22) & 0x1) == 0)
16261                                         {
16262                                           if (((word >> 23) & 0x1) == 0)
16263                                             {
16264                                               /* 33222222222211111111110000000000
16265                                                  10987654321098765432109876543210
16266                                                  x10101x0000xxxxxxxxxx0xxxxx1xxxx
16267                                                  braaz.  */
16268                                               return 647;
16269                                             }
16270                                           else
16271                                             {
16272                                               /* 33222222222211111111110000000000
16273                                                  10987654321098765432109876543210
16274                                                  x10101x0100xxxxxxxxxx0xxxxx1xxxx
16275                                                  eretaa.  */
16276                                               return 653;
16277                                             }
16278                                         }
16279                                       else
16280                                         {
16281                                           /* 33222222222211111111110000000000
16282                                              10987654321098765432109876543210
16283                                              x10101x0x10xxxxxxxxxx0xxxxx1xxxx
16284                                              retaa.  */
16285                                           return 651;
16286                                         }
16287                                     }
16288                                   else
16289                                     {
16290                                       /* 33222222222211111111110000000000
16291                                          10987654321098765432109876543210
16292                                          x10101x0xx1xxxxxxxxxx0xxxxx1xxxx
16293                                          blraaz.  */
16294                                       return 649;
16295                                     }
16296                                 }
16297                               else
16298                                 {
16299                                   if (((word >> 21) & 0x1) == 0)
16300                                     {
16301                                       if (((word >> 22) & 0x1) == 0)
16302                                         {
16303                                           if (((word >> 23) & 0x1) == 0)
16304                                             {
16305                                               /* 33222222222211111111110000000000
16306                                                  10987654321098765432109876543210
16307                                                  x10101x0000xxxxxxxxxx1xxxxx1xxxx
16308                                                  brabz.  */
16309                                               return 648;
16310                                             }
16311                                           else
16312                                             {
16313                                               /* 33222222222211111111110000000000
16314                                                  10987654321098765432109876543210
16315                                                  x10101x0100xxxxxxxxxx1xxxxx1xxxx
16316                                                  eretab.  */
16317                                               return 654;
16318                                             }
16319                                         }
16320                                       else
16321                                         {
16322                                           /* 33222222222211111111110000000000
16323                                              10987654321098765432109876543210
16324                                              x10101x0x10xxxxxxxxxx1xxxxx1xxxx
16325                                              retab.  */
16326                                           return 652;
16327                                         }
16328                                     }
16329                                   else
16330                                     {
16331                                       /* 33222222222211111111110000000000
16332                                          10987654321098765432109876543210
16333                                          x10101x0xx1xxxxxxxxxx1xxxxx1xxxx
16334                                          blrabz.  */
16335                                       return 650;
16336                                     }
16337                                 }
16338                             }
16339                         }
16340                       else
16341                         {
16342                           if (((word >> 21) & 0x1) == 0)
16343                             {
16344                               if (((word >> 25) & 0x1) == 0)
16345                                 {
16346                                   /* 33222222222211111111110000000000
16347                                      10987654321098765432109876543210
16348                                      x1010101xx0xxxxxxxxxxxxxxxxxxxxx
16349                                      xaflag.  */
16350                                   return 811;
16351                                 }
16352                               else
16353                                 {
16354                                   if (((word >> 10) & 0x1) == 0)
16355                                     {
16356                                       /* 33222222222211111111110000000000
16357                                          10987654321098765432109876543210
16358                                          x1010111xx0xxxxxxxxxx0xxxxxxxxxx
16359                                          braa.  */
16360                                       return 643;
16361                                     }
16362                                   else
16363                                     {
16364                                       /* 33222222222211111111110000000000
16365                                          10987654321098765432109876543210
16366                                          x1010111xx0xxxxxxxxxx1xxxxxxxxxx
16367                                          brab.  */
16368                                       return 644;
16369                                     }
16370                                 }
16371                             }
16372                           else
16373                             {
16374                               if (((word >> 25) & 0x1) == 0)
16375                                 {
16376                                   /* 33222222222211111111110000000000
16377                                      10987654321098765432109876543210
16378                                      x1010101xx1xxxxxxxxxxxxxxxxxxxxx
16379                                      tstart.  */
16380                                   return 1193;
16381                                 }
16382                               else
16383                                 {
16384                                   if (((word >> 10) & 0x1) == 0)
16385                                     {
16386                                       /* 33222222222211111111110000000000
16387                                          10987654321098765432109876543210
16388                                          x1010111xx1xxxxxxxxxx0xxxxxxxxxx
16389                                          blraa.  */
16390                                       return 645;
16391                                     }
16392                                   else
16393                                     {
16394                                       /* 33222222222211111111110000000000
16395                                          10987654321098765432109876543210
16396                                          x1010111xx1xxxxxxxxxx1xxxxxxxxxx
16397                                          blrab.  */
16398                                       return 646;
16399                                     }
16400                                 }
16401                             }
16402                         }
16403                     }
16404                 }
16405               else
16406                 {
16407                   if (((word >> 24) & 0x1) == 0)
16408                     {
16409                       if (((word >> 25) & 0x1) == 0)
16410                         {
16411                           /* 33222222222211111111110000000000
16412                              10987654321098765432109876543210
16413                              xx110100xxxxxxxxxxxxxxxxxxxxxxxx
16414                              cbz.  */
16415                           return 655;
16416                         }
16417                       else
16418                         {
16419                           /* 33222222222211111111110000000000
16420                              10987654321098765432109876543210
16421                              xx110110xxxxxxxxxxxxxxxxxxxxxxxx
16422                              tbz.  */
16423                           return 1251;
16424                         }
16425                     }
16426                   else
16427                     {
16428                       if (((word >> 25) & 0x1) == 0)
16429                         {
16430                           /* 33222222222211111111110000000000
16431                              10987654321098765432109876543210
16432                              xx110101xxxxxxxxxxxxxxxxxxxxxxxx
16433                              cbnz.  */
16434                           return 656;
16435                         }
16436                       else
16437                         {
16438                           /* 33222222222211111111110000000000
16439                              10987654321098765432109876543210
16440                              xx110111xxxxxxxxxxxxxxxxxxxxxxxx
16441                              tbnz.  */
16442                           return 1252;
16443                         }
16444                     }
16445                 }
16446             }
16447         }
16448       else
16449         {
16450           if (((word >> 25) & 0x1) == 0)
16451             {
16452               if (((word >> 28) & 0x1) == 0)
16453                 {
16454                   if (((word >> 22) & 0x1) == 0)
16455                     {
16456                       if (((word >> 23) & 0x1) == 0)
16457                         {
16458                           if (((word >> 24) & 0x1) == 0)
16459                             {
16460                               if (((word >> 29) & 0x1) == 0)
16461                                 {
16462                                   /* 33222222222211111111110000000000
16463                                      10987654321098765432109876543210
16464                                      xx00110000xxxxxxxxxxxxxxxxxxxxxx
16465                                      st4.  */
16466                                   return 440;
16467                                 }
16468                               else
16469                                 {
16470                                   /* 33222222222211111111110000000000
16471                                      10987654321098765432109876543210
16472                                      xx10110000xxxxxxxxxxxxxxxxxxxxxx
16473                                      stnp.  */
16474                                   return 973;
16475                                 }
16476                             }
16477                           else
16478                             {
16479                               if (((word >> 29) & 0x1) == 0)
16480                                 {
16481                                   if (((word >> 13) & 0x1) == 0)
16482                                     {
16483                                       if (((word >> 21) & 0x1) == 0)
16484                                         {
16485                                           /* 33222222222211111111110000000000
16486                                              10987654321098765432109876543210
16487                                              xx001101000xxxxxxx0xxxxxxxxxxxxx
16488                                              st1.  */
16489                                           return 456;
16490                                         }
16491                                       else
16492                                         {
16493                                           /* 33222222222211111111110000000000
16494                                              10987654321098765432109876543210
16495                                              xx001101001xxxxxxx0xxxxxxxxxxxxx
16496                                              st2.  */
16497                                           return 458;
16498                                         }
16499                                     }
16500                                   else
16501                                     {
16502                                       if (((word >> 21) & 0x1) == 0)
16503                                         {
16504                                           /* 33222222222211111111110000000000
16505                                              10987654321098765432109876543210
16506                                              xx001101000xxxxxxx1xxxxxxxxxxxxx
16507                                              st3.  */
16508                                           return 457;
16509                                         }
16510                                       else
16511                                         {
16512                                           /* 33222222222211111111110000000000
16513                                              10987654321098765432109876543210
16514                                              xx001101001xxxxxxx1xxxxxxxxxxxxx
16515                                              st4.  */
16516                                           return 459;
16517                                         }
16518                                     }
16519                                 }
16520                               else
16521                                 {
16522                                   /* 33222222222211111111110000000000
16523                                      10987654321098765432109876543210
16524                                      xx10110100xxxxxxxxxxxxxxxxxxxxxx
16525                                      stp.  */
16526                                   return 977;
16527                                 }
16528                             }
16529                         }
16530                       else
16531                         {
16532                           if (((word >> 29) & 0x1) == 0)
16533                             {
16534                               if (((word >> 21) & 0x1) == 0)
16535                                 {
16536                                   if (((word >> 24) & 0x1) == 0)
16537                                     {
16538                                       /* 33222222222211111111110000000000
16539                                          10987654321098765432109876543210
16540                                          xx001100100xxxxxxxxxxxxxxxxxxxxx
16541                                          st4.  */
16542                                       return 448;
16543                                     }
16544                                   else
16545                                     {
16546                                       if (((word >> 13) & 0x1) == 0)
16547                                         {
16548                                           /* 33222222222211111111110000000000
16549                                              10987654321098765432109876543210
16550                                              xx001101100xxxxxxx0xxxxxxxxxxxxx
16551                                              st1.  */
16552                                           return 468;
16553                                         }
16554                                       else
16555                                         {
16556                                           /* 33222222222211111111110000000000
16557                                              10987654321098765432109876543210
16558                                              xx001101100xxxxxxx1xxxxxxxxxxxxx
16559                                              st3.  */
16560                                           return 469;
16561                                         }
16562                                     }
16563                                 }
16564                               else
16565                                 {
16566                                   if (((word >> 13) & 0x1) == 0)
16567                                     {
16568                                       /* 33222222222211111111110000000000
16569                                          10987654321098765432109876543210
16570                                          xx00110x101xxxxxxx0xxxxxxxxxxxxx
16571                                          st2.  */
16572                                       return 470;
16573                                     }
16574                                   else
16575                                     {
16576                                       /* 33222222222211111111110000000000
16577                                          10987654321098765432109876543210
16578                                          xx00110x101xxxxxxx1xxxxxxxxxxxxx
16579                                          st4.  */
16580                                       return 471;
16581                                     }
16582                                 }
16583                             }
16584                           else
16585                             {
16586                               /* 33222222222211111111110000000000
16587                                  10987654321098765432109876543210
16588                                  xx10110x10xxxxxxxxxxxxxxxxxxxxxx
16589                                  stp.  */
16590                               return 983;
16591                             }
16592                         }
16593                     }
16594                   else
16595                     {
16596                       if (((word >> 23) & 0x1) == 0)
16597                         {
16598                           if (((word >> 24) & 0x1) == 0)
16599                             {
16600                               if (((word >> 29) & 0x1) == 0)
16601                                 {
16602                                   /* 33222222222211111111110000000000
16603                                      10987654321098765432109876543210
16604                                      xx00110001xxxxxxxxxxxxxxxxxxxxxx
16605                                      ld4.  */
16606                                   return 444;
16607                                 }
16608                               else
16609                                 {
16610                                   /* 33222222222211111111110000000000
16611                                      10987654321098765432109876543210
16612                                      xx10110001xxxxxxxxxxxxxxxxxxxxxx
16613                                      ldnp.  */
16614                                   return 974;
16615                                 }
16616                             }
16617                           else
16618                             {
16619                               if (((word >> 29) & 0x1) == 0)
16620                                 {
16621                                   if (((word >> 13) & 0x1) == 0)
16622                                     {
16623                                       if (((word >> 21) & 0x1) == 0)
16624                                         {
16625                                           /* 33222222222211111111110000000000
16626                                              10987654321098765432109876543210
16627                                              xx001101010xxxxxxx0xxxxxxxxxxxxx
16628                                              ld1.  */
16629                                           return 460;
16630                                         }
16631                                       else
16632                                         {
16633                                           /* 33222222222211111111110000000000
16634                                              10987654321098765432109876543210
16635                                              xx001101011xxxxxxx0xxxxxxxxxxxxx
16636                                              ld2.  */
16637                                           return 464;
16638                                         }
16639                                     }
16640                                   else
16641                                     {
16642                                       if (((word >> 21) & 0x1) == 0)
16643                                         {
16644                                           /* 33222222222211111111110000000000
16645                                              10987654321098765432109876543210
16646                                              xx001101010xxxxxxx1xxxxxxxxxxxxx
16647                                              ld3.  */
16648                                           return 461;
16649                                         }
16650                                       else
16651                                         {
16652                                           /* 33222222222211111111110000000000
16653                                              10987654321098765432109876543210
16654                                              xx001101011xxxxxxx1xxxxxxxxxxxxx
16655                                              ld4.  */
16656                                           return 465;
16657                                         }
16658                                     }
16659                                 }
16660                               else
16661                                 {
16662                                   /* 33222222222211111111110000000000
16663                                      10987654321098765432109876543210
16664                                      xx10110101xxxxxxxxxxxxxxxxxxxxxx
16665                                      ldp.  */
16666                                   return 978;
16667                                 }
16668                             }
16669                         }
16670                       else
16671                         {
16672                           if (((word >> 29) & 0x1) == 0)
16673                             {
16674                               if (((word >> 21) & 0x1) == 0)
16675                                 {
16676                                   if (((word >> 24) & 0x1) == 0)
16677                                     {
16678                                       /* 33222222222211111111110000000000
16679                                          10987654321098765432109876543210
16680                                          xx001100110xxxxxxxxxxxxxxxxxxxxx
16681                                          ld4.  */
16682                                       return 452;
16683                                     }
16684                                   else
16685                                     {
16686                                       if (((word >> 13) & 0x1) == 0)
16687                                         {
16688                                           /* 33222222222211111111110000000000
16689                                              10987654321098765432109876543210
16690                                              xx001101110xxxxxxx0xxxxxxxxxxxxx
16691                                              ld1.  */
16692                                           return 472;
16693                                         }
16694                                       else
16695                                         {
16696                                           /* 33222222222211111111110000000000
16697                                              10987654321098765432109876543210
16698                                              xx001101110xxxxxxx1xxxxxxxxxxxxx
16699                                              ld3.  */
16700                                           return 473;
16701                                         }
16702                                     }
16703                                 }
16704                               else
16705                                 {
16706                                   if (((word >> 13) & 0x1) == 0)
16707                                     {
16708                                       /* 33222222222211111111110000000000
16709                                          10987654321098765432109876543210
16710                                          xx00110x111xxxxxxx0xxxxxxxxxxxxx
16711                                          ld2.  */
16712                                       return 476;
16713                                     }
16714                                   else
16715                                     {
16716                                       /* 33222222222211111111110000000000
16717                                          10987654321098765432109876543210
16718                                          xx00110x111xxxxxxx1xxxxxxxxxxxxx
16719                                          ld4.  */
16720                                       return 477;
16721                                     }
16722                                 }
16723                             }
16724                           else
16725                             {
16726                               /* 33222222222211111111110000000000
16727                                  10987654321098765432109876543210
16728                                  xx10110x11xxxxxxxxxxxxxxxxxxxxxx
16729                                  ldp.  */
16730                               return 984;
16731                             }
16732                         }
16733                     }
16734                 }
16735               else
16736                 {
16737                   if (((word >> 24) & 0x1) == 0)
16738                     {
16739                       if (((word >> 29) & 0x1) == 0)
16740                         {
16741                           /* 33222222222211111111110000000000
16742                              10987654321098765432109876543210
16743                              xx011100xxxxxxxxxxxxxxxxxxxxxxxx
16744                              ldr.  */
16745                           return 988;
16746                         }
16747                       else
16748                         {
16749                           if (((word >> 10) & 0x1) == 0)
16750                             {
16751                               if (((word >> 11) & 0x1) == 0)
16752                                 {
16753                                   if (((word >> 22) & 0x1) == 0)
16754                                     {
16755                                       /* 33222222222211111111110000000000
16756                                          10987654321098765432109876543210
16757                                          xx111100x0xxxxxxxxxx00xxxxxxxxxx
16758                                          stur.  */
16759                                       return 925;
16760                                     }
16761                                   else
16762                                     {
16763                                       /* 33222222222211111111110000000000
16764                                          10987654321098765432109876543210
16765                                          xx111100x1xxxxxxxxxx00xxxxxxxxxx
16766                                          ldur.  */
16767                                       return 926;
16768                                     }
16769                                 }
16770                               else
16771                                 {
16772                                   if (((word >> 22) & 0x1) == 0)
16773                                     {
16774                                       /* 33222222222211111111110000000000
16775                                          10987654321098765432109876543210
16776                                          xx111100x0xxxxxxxxxx10xxxxxxxxxx
16777                                          str.  */
16778                                       return 904;
16779                                     }
16780                                   else
16781                                     {
16782                                       /* 33222222222211111111110000000000
16783                                          10987654321098765432109876543210
16784                                          xx111100x1xxxxxxxxxx10xxxxxxxxxx
16785                                          ldr.  */
16786                                       return 905;
16787                                     }
16788                                 }
16789                             }
16790                           else
16791                             {
16792                               if (((word >> 22) & 0x1) == 0)
16793                                 {
16794                                   /* 33222222222211111111110000000000
16795                                      10987654321098765432109876543210
16796                                      xx111100x0xxxxxxxxxxx1xxxxxxxxxx
16797                                      str.  */
16798                                   return 873;
16799                                 }
16800                               else
16801                                 {
16802                                   /* 33222222222211111111110000000000
16803                                      10987654321098765432109876543210
16804                                      xx111100x1xxxxxxxxxxx1xxxxxxxxxx
16805                                      ldr.  */
16806                                   return 874;
16807                                 }
16808                             }
16809                         }
16810                     }
16811                   else
16812                     {
16813                       if (((word >> 22) & 0x1) == 0)
16814                         {
16815                           /* 33222222222211111111110000000000
16816                              10987654321098765432109876543210
16817                              xxx11101x0xxxxxxxxxxxxxxxxxxxxxx
16818                              str.  */
16819                           return 892;
16820                         }
16821                       else
16822                         {
16823                           /* 33222222222211111111110000000000
16824                              10987654321098765432109876543210
16825                              xxx11101x1xxxxxxxxxxxxxxxxxxxxxx
16826                              ldr.  */
16827                           return 893;
16828                         }
16829                     }
16830                 }
16831             }
16832           else
16833             {
16834               if (((word >> 24) & 0x1) == 0)
16835                 {
16836                   if (((word >> 21) & 0x1) == 0)
16837                     {
16838                       if (((word >> 28) & 0x1) == 0)
16839                         {
16840                           if (((word >> 29) & 0x1) == 0)
16841                             {
16842                               if (((word >> 31) & 0x1) == 0)
16843                                 {
16844                                   if (((word >> 10) & 0x1) == 0)
16845                                     {
16846                                       if (((word >> 11) & 0x1) == 0)
16847                                         {
16848                                           if (((word >> 12) & 0x1) == 0)
16849                                             {
16850                                               /* 33222222222211111111110000000000
16851                                                  10987654321098765432109876543210
16852                                                  0x001110xx0xxxxxxxx000xxxxxxxxxx
16853                                                  tbl.  */
16854                                               return 420;
16855                                             }
16856                                           else
16857                                             {
16858                                               /* 33222222222211111111110000000000
16859                                                  10987654321098765432109876543210
16860                                                  0x001110xx0xxxxxxxx100xxxxxxxxxx
16861                                                  tbx.  */
16862                                               return 421;
16863                                             }
16864                                         }
16865                                       else
16866                                         {
16867                                           if (((word >> 12) & 0x1) == 0)
16868                                             {
16869                                               if (((word >> 14) & 0x1) == 0)
16870                                                 {
16871                                                   /* 33222222222211111111110000000000
16872                                                      10987654321098765432109876543210
16873                                                      0x001110xx0xxxxxx0x010xxxxxxxxxx
16874                                                      trn1.  */
16875                                                   return 263;
16876                                                 }
16877                                               else
16878                                                 {
16879                                                   /* 33222222222211111111110000000000
16880                                                      10987654321098765432109876543210
16881                                                      0x001110xx0xxxxxx1x010xxxxxxxxxx
16882                                                      trn2.  */
16883                                                   return 266;
16884                                                 }
16885                                             }
16886                                           else
16887                                             {
16888                                               if (((word >> 13) & 0x1) == 0)
16889                                                 {
16890                                                   if (((word >> 14) & 0x1) == 0)
16891                                                     {
16892                                                       /* 33222222222211111111110000000000
16893                                                          10987654321098765432109876543210
16894                                                          0x001110xx0xxxxxx00110xxxxxxxxxx
16895                                                          uzp1.  */
16896                                                       return 262;
16897                                                     }
16898                                                   else
16899                                                     {
16900                                                       /* 33222222222211111111110000000000
16901                                                          10987654321098765432109876543210
16902                                                          0x001110xx0xxxxxx10110xxxxxxxxxx
16903                                                          uzp2.  */
16904                                                       return 265;
16905                                                     }
16906                                                 }
16907                                               else
16908                                                 {
16909                                                   if (((word >> 14) & 0x1) == 0)
16910                                                     {
16911                                                       /* 33222222222211111111110000000000
16912                                                          10987654321098765432109876543210
16913                                                          0x001110xx0xxxxxx01110xxxxxxxxxx
16914                                                          zip1.  */
16915                                                       return 264;
16916                                                     }
16917                                                   else
16918                                                     {
16919                                                       /* 33222222222211111111110000000000
16920                                                          10987654321098765432109876543210
16921                                                          0x001110xx0xxxxxx11110xxxxxxxxxx
16922                                                          zip2.  */
16923                                                       return 267;
16924                                                     }
16925                                                 }
16926                                             }
16927                                         }
16928                                     }
16929                                   else
16930                                     {
16931                                       if (((word >> 11) & 0x1) == 0)
16932                                         {
16933                                           if (((word >> 12) & 0x1) == 0)
16934                                             {
16935                                               if (((word >> 13) & 0x1) == 0)
16936                                                 {
16937                                                   if (((word >> 22) & 0x1) == 0)
16938                                                     {
16939                                                       /* 33222222222211111111110000000000
16940                                                          10987654321098765432109876543210
16941                                                          0x001110x00xxxxxxx0001xxxxxxxxxx
16942                                                          dup.  */
16943                                                       return 149;
16944                                                     }
16945                                                   else
16946                                                     {
16947                                                       if (((word >> 23) & 0x1) == 0)
16948                                                         {
16949                                                           /* 33222222222211111111110000000000
16950                                                              10987654321098765432109876543210
16951                                                              0x001110010xxxxxxx0001xxxxxxxxxx
16952                                                              fmaxnm.  */
16953                                                           return 292;
16954                                                         }
16955                                                       else
16956                                                         {
16957                                                           /* 33222222222211111111110000000000
16958                                                              10987654321098765432109876543210
16959                                                              0x001110110xxxxxxx0001xxxxxxxxxx
16960                                                              fminnm.  */
16961                                                           return 308;
16962                                                         }
16963                                                     }
16964                                                 }
16965                                               else
16966                                                 {
16967                                                   if (((word >> 15) & 0x1) == 0)
16968                                                     {
16969                                                       /* 33222222222211111111110000000000
16970                                                          10987654321098765432109876543210
16971                                                          0x001110xx0xxxxx0x1001xxxxxxxxxx
16972                                                          fcmeq.  */
16973                                                       return 300;
16974                                                     }
16975                                                   else
16976                                                     {
16977                                                       /* 33222222222211111111110000000000
16978                                                          10987654321098765432109876543210
16979                                                          0x001110xx0xxxxx1x1001xxxxxxxxxx
16980                                                          smmla.  */
16981                                                       return 2486;
16982                                                     }
16983                                                 }
16984                                             }
16985                                           else
16986                                             {
16987                                               if (((word >> 13) & 0x1) == 0)
16988                                                 {
16989                                                   if (((word >> 15) & 0x1) == 0)
16990                                                     {
16991                                                       if (((word >> 23) & 0x1) == 0)
16992                                                         {
16993                                                           /* 33222222222211111111110000000000
16994                                                              10987654321098765432109876543210
16995                                                              0x0011100x0xxxxx0x0101xxxxxxxxxx
16996                                                              fadd.  */
16997                                                           return 296;
16998                                                         }
16999                                                       else
17000                                                         {
17001                                                           /* 33222222222211111111110000000000
17002                                                              10987654321098765432109876543210
17003                                                              0x0011101x0xxxxx0x0101xxxxxxxxxx
17004                                                              fsub.  */
17005                                                           return 312;
17006                                                         }
17007                                                     }
17008                                                   else
17009                                                     {
17010                                                       /* 33222222222211111111110000000000
17011                                                          10987654321098765432109876543210
17012                                                          0x001110xx0xxxxx1x0101xxxxxxxxxx
17013                                                          sdot.  */
17014                                                       return 2412;
17015                                                     }
17016                                                 }
17017                                               else
17018                                                 {
17019                                                   if (((word >> 23) & 0x1) == 0)
17020                                                     {
17021                                                       /* 33222222222211111111110000000000
17022                                                          10987654321098765432109876543210
17023                                                          0x0011100x0xxxxxxx1101xxxxxxxxxx
17024                                                          fmax.  */
17025                                                       return 302;
17026                                                     }
17027                                                   else
17028                                                     {
17029                                                       /* 33222222222211111111110000000000
17030                                                          10987654321098765432109876543210
17031                                                          0x0011101x0xxxxxxx1101xxxxxxxxxx
17032                                                          fmin.  */
17033                                                       return 314;
17034                                                     }
17035                                                 }
17036                                             }
17037                                         }
17038                                       else
17039                                         {
17040                                           if (((word >> 12) & 0x1) == 0)
17041                                             {
17042                                               if (((word >> 13) & 0x1) == 0)
17043                                                 {
17044                                                   if (((word >> 22) & 0x1) == 0)
17045                                                     {
17046                                                       /* 33222222222211111111110000000000
17047                                                          10987654321098765432109876543210
17048                                                          0x001110x00xxxxxxx0011xxxxxxxxxx
17049                                                          dup.  */
17050                                                       return 150;
17051                                                     }
17052                                                   else
17053                                                     {
17054                                                       if (((word >> 23) & 0x1) == 0)
17055                                                         {
17056                                                           /* 33222222222211111111110000000000
17057                                                              10987654321098765432109876543210
17058                                                              0x001110010xxxxxxx0011xxxxxxxxxx
17059                                                              fmla.  */
17060                                                           return 294;
17061                                                         }
17062                                                       else
17063                                                         {
17064                                                           /* 33222222222211111111110000000000
17065                                                              10987654321098765432109876543210
17066                                                              0x001110110xxxxxxx0011xxxxxxxxxx
17067                                                              fmls.  */
17068                                                           return 310;
17069                                                         }
17070                                                     }
17071                                                 }
17072                                               else
17073                                                 {
17074                                                   if (((word >> 15) & 0x1) == 0)
17075                                                     {
17076                                                       /* 33222222222211111111110000000000
17077                                                          10987654321098765432109876543210
17078                                                          0x001110xx0xxxxx0x1011xxxxxxxxxx
17079                                                          smov.  */
17080                                                       return 151;
17081                                                     }
17082                                                   else
17083                                                     {
17084                                                       /* 33222222222211111111110000000000
17085                                                          10987654321098765432109876543210
17086                                                          0x001110xx0xxxxx1x1011xxxxxxxxxx
17087                                                          usmmla.  */
17088                                                       return 2488;
17089                                                     }
17090                                                 }
17091                                             }
17092                                           else
17093                                             {
17094                                               if (((word >> 13) & 0x1) == 0)
17095                                                 {
17096                                                   if (((word >> 15) & 0x1) == 0)
17097                                                     {
17098                                                       if (((word >> 22) & 0x1) == 0)
17099                                                         {
17100                                                           /* 33222222222211111111110000000000
17101                                                              10987654321098765432109876543210
17102                                                              0x001110x00xxxxx0x0111xxxxxxxxxx
17103                                                              ins.  */
17104                                                           return 154;
17105                                                         }
17106                                                       else
17107                                                         {
17108                                                           /* 33222222222211111111110000000000
17109                                                              10987654321098765432109876543210
17110                                                              0x001110x10xxxxx0x0111xxxxxxxxxx
17111                                                              fmulx.  */
17112                                                           return 298;
17113                                                         }
17114                                                     }
17115                                                   else
17116                                                     {
17117                                                       /* 33222222222211111111110000000000
17118                                                          10987654321098765432109876543210
17119                                                          0x001110xx0xxxxx1x0111xxxxxxxxxx
17120                                                          usdot.  */
17121                                                       return 2489;
17122                                                     }
17123                                                 }
17124                                               else
17125                                                 {
17126                                                   if (((word >> 22) & 0x1) == 0)
17127                                                     {
17128                                                       /* 33222222222211111111110000000000
17129                                                          10987654321098765432109876543210
17130                                                          0x001110x00xxxxxxx1111xxxxxxxxxx
17131                                                          umov.  */
17132                                                       return 152;
17133                                                     }
17134                                                   else
17135                                                     {
17136                                                       if (((word >> 23) & 0x1) == 0)
17137                                                         {
17138                                                           /* 33222222222211111111110000000000
17139                                                              10987654321098765432109876543210
17140                                                              0x001110010xxxxxxx1111xxxxxxxxxx
17141                                                              frecps.  */
17142                                                           return 304;
17143                                                         }
17144                                                       else
17145                                                         {
17146                                                           /* 33222222222211111111110000000000
17147                                                              10987654321098765432109876543210
17148                                                              0x001110110xxxxxxx1111xxxxxxxxxx
17149                                                              frsqrts.  */
17150                                                           return 316;
17151                                                         }
17152                                                     }
17153                                                 }
17154                                             }
17155                                         }
17156                                     }
17157                                 }
17158                               else
17159                                 {
17160                                   if (((word >> 22) & 0x1) == 0)
17161                                     {
17162                                       if (((word >> 23) & 0x1) == 0)
17163                                         {
17164                                           /* 33222222222211111111110000000000
17165                                              10987654321098765432109876543210
17166                                              1x001110000xxxxxxxxxxxxxxxxxxxxx
17167                                              eor3.  */
17168                                           return 2419;
17169                                         }
17170                                       else
17171                                         {
17172                                           /* 33222222222211111111110000000000
17173                                              10987654321098765432109876543210
17174                                              1x001110100xxxxxxxxxxxxxxxxxxxxx
17175                                              xar.  */
17176                                           return 2421;
17177                                         }
17178                                     }
17179                                   else
17180                                     {
17181                                       if (((word >> 15) & 0x1) == 0)
17182                                         {
17183                                           /* 33222222222211111111110000000000
17184                                              10987654321098765432109876543210
17185                                              1x001110x10xxxxx0xxxxxxxxxxxxxxx
17186                                              sm3ss1.  */
17187                                           return 2423;
17188                                         }
17189                                       else
17190                                         {
17191                                           if (((word >> 10) & 0x1) == 0)
17192                                             {
17193                                               if (((word >> 11) & 0x1) == 0)
17194                                                 {
17195                                                   if (((word >> 23) & 0x1) == 0)
17196                                                     {
17197                                                       /* 33222222222211111111110000000000
17198                                                          10987654321098765432109876543210
17199                                                          1x001110010xxxxx1xxx00xxxxxxxxxx
17200                                                          sm3tt1a.  */
17201                                                       return 2424;
17202                                                     }
17203                                                   else
17204                                                     {
17205                                                       /* 33222222222211111111110000000000
17206                                                          10987654321098765432109876543210
17207                                                          1x001110110xxxxx1xxx00xxxxxxxxxx
17208                                                          sha512su0.  */
17209                                                       return 2417;
17210                                                     }
17211                                                 }
17212                                               else
17213                                                 {
17214                                                   /* 33222222222211111111110000000000
17215                                                      10987654321098765432109876543210
17216                                                      1x001110x10xxxxx1xxx10xxxxxxxxxx
17217                                                      sm3tt2a.  */
17218                                                   return 2426;
17219                                                 }
17220                                             }
17221                                           else
17222                                             {
17223                                               if (((word >> 11) & 0x1) == 0)
17224                                                 {
17225                                                   if (((word >> 23) & 0x1) == 0)
17226                                                     {
17227                                                       /* 33222222222211111111110000000000
17228                                                          10987654321098765432109876543210
17229                                                          1x001110010xxxxx1xxx01xxxxxxxxxx
17230                                                          sm3tt1b.  */
17231                                                       return 2425;
17232                                                     }
17233                                                   else
17234                                                     {
17235                                                       /* 33222222222211111111110000000000
17236                                                          10987654321098765432109876543210
17237                                                          1x001110110xxxxx1xxx01xxxxxxxxxx
17238                                                          sm4e.  */
17239                                                       return 2430;
17240                                                     }
17241                                                 }
17242                                               else
17243                                                 {
17244                                                   /* 33222222222211111111110000000000
17245                                                      10987654321098765432109876543210
17246                                                      1x001110x10xxxxx1xxx11xxxxxxxxxx
17247                                                      sm3tt2b.  */
17248                                                   return 2427;
17249                                                 }
17250                                             }
17251                                         }
17252                                     }
17253                                 }
17254                             }
17255                           else
17256                             {
17257                               if (((word >> 10) & 0x1) == 0)
17258                                 {
17259                                   /* 33222222222211111111110000000000
17260                                      10987654321098765432109876543210
17261                                      xx101110xx0xxxxxxxxxx0xxxxxxxxxx
17262                                      ext.  */
17263                                   return 132;
17264                                 }
17265                               else
17266                                 {
17267                                   if (((word >> 15) & 0x1) == 0)
17268                                     {
17269                                       if (((word >> 22) & 0x1) == 0)
17270                                         {
17271                                           /* 33222222222211111111110000000000
17272                                              10987654321098765432109876543210
17273                                              xx101110x00xxxxx0xxxx1xxxxxxxxxx
17274                                              ins.  */
17275                                           return 156;
17276                                         }
17277                                       else
17278                                         {
17279                                           if (((word >> 11) & 0x1) == 0)
17280                                             {
17281                                               if (((word >> 12) & 0x1) == 0)
17282                                                 {
17283                                                   if (((word >> 13) & 0x1) == 0)
17284                                                     {
17285                                                       if (((word >> 23) & 0x1) == 0)
17286                                                         {
17287                                                           /* 33222222222211111111110000000000
17288                                                              10987654321098765432109876543210
17289                                                              xx101110010xxxxx0x0001xxxxxxxxxx
17290                                                              fmaxnmp.  */
17291                                                           return 343;
17292                                                         }
17293                                                       else
17294                                                         {
17295                                                           /* 33222222222211111111110000000000
17296                                                              10987654321098765432109876543210
17297                                                              xx101110110xxxxx0x0001xxxxxxxxxx
17298                                                              fminnmp.  */
17299                                                           return 359;
17300                                                         }
17301                                                     }
17302                                                   else
17303                                                     {
17304                                                       if (((word >> 23) & 0x1) == 0)
17305                                                         {
17306                                                           /* 33222222222211111111110000000000
17307                                                              10987654321098765432109876543210
17308                                                              xx101110010xxxxx0x1001xxxxxxxxxx
17309                                                              fcmge.  */
17310                                                           return 349;
17311                                                         }
17312                                                       else
17313                                                         {
17314                                                           /* 33222222222211111111110000000000
17315                                                              10987654321098765432109876543210
17316                                                              xx101110110xxxxx0x1001xxxxxxxxxx
17317                                                              fcmgt.  */
17318                                                           return 363;
17319                                                         }
17320                                                     }
17321                                                 }
17322                                               else
17323                                                 {
17324                                                   if (((word >> 13) & 0x1) == 0)
17325                                                     {
17326                                                       if (((word >> 23) & 0x1) == 0)
17327                                                         {
17328                                                           /* 33222222222211111111110000000000
17329                                                              10987654321098765432109876543210
17330                                                              xx101110010xxxxx0x0101xxxxxxxxxx
17331                                                              faddp.  */
17332                                                           return 345;
17333                                                         }
17334                                                       else
17335                                                         {
17336                                                           /* 33222222222211111111110000000000
17337                                                              10987654321098765432109876543210
17338                                                              xx101110110xxxxx0x0101xxxxxxxxxx
17339                                                              fabd.  */
17340                                                           return 361;
17341                                                         }
17342                                                     }
17343                                                   else
17344                                                     {
17345                                                       if (((word >> 23) & 0x1) == 0)
17346                                                         {
17347                                                           /* 33222222222211111111110000000000
17348                                                              10987654321098765432109876543210
17349                                                              xx101110010xxxxx0x1101xxxxxxxxxx
17350                                                              fmaxp.  */
17351                                                           return 353;
17352                                                         }
17353                                                       else
17354                                                         {
17355                                                           /* 33222222222211111111110000000000
17356                                                              10987654321098765432109876543210
17357                                                              xx101110110xxxxx0x1101xxxxxxxxxx
17358                                                              fminp.  */
17359                                                           return 367;
17360                                                         }
17361                                                     }
17362                                                 }
17363                                             }
17364                                           else
17365                                             {
17366                                               if (((word >> 12) & 0x1) == 0)
17367                                                 {
17368                                                   if (((word >> 23) & 0x1) == 0)
17369                                                     {
17370                                                       /* 33222222222211111111110000000000
17371                                                          10987654321098765432109876543210
17372                                                          xx101110010xxxxx0xx011xxxxxxxxxx
17373                                                          facge.  */
17374                                                       return 351;
17375                                                     }
17376                                                   else
17377                                                     {
17378                                                       /* 33222222222211111111110000000000
17379                                                          10987654321098765432109876543210
17380                                                          xx101110110xxxxx0xx011xxxxxxxxxx
17381                                                          facgt.  */
17382                                                       return 365;
17383                                                     }
17384                                                 }
17385                                               else
17386                                                 {
17387                                                   if (((word >> 13) & 0x1) == 0)
17388                                                     {
17389                                                       /* 33222222222211111111110000000000
17390                                                          10987654321098765432109876543210
17391                                                          xx101110x10xxxxx0x0111xxxxxxxxxx
17392                                                          fmul.  */
17393                                                       return 347;
17394                                                     }
17395                                                   else
17396                                                     {
17397                                                       /* 33222222222211111111110000000000
17398                                                          10987654321098765432109876543210
17399                                                          xx101110x10xxxxx0x1111xxxxxxxxxx
17400                                                          fdiv.  */
17401                                                       return 355;
17402                                                     }
17403                                                 }
17404                                             }
17405                                         }
17406                                     }
17407                                   else
17408                                     {
17409                                       if (((word >> 13) & 0x1) == 0)
17410                                         {
17411                                           if (((word >> 14) & 0x1) == 0)
17412                                             {
17413                                               if (((word >> 11) & 0x1) == 0)
17414                                                 {
17415                                                   if (((word >> 12) & 0x1) == 0)
17416                                                     {
17417                                                       /* 33222222222211111111110000000000
17418                                                          10987654321098765432109876543210
17419                                                          xx101110xx0xxxxx100001xxxxxxxxxx
17420                                                          sqrdmlah.  */
17421                                                       return 370;
17422                                                     }
17423                                                   else
17424                                                     {
17425                                                       /* 33222222222211111111110000000000
17426                                                          10987654321098765432109876543210
17427                                                          xx101110xx0xxxxx100101xxxxxxxxxx
17428                                                          udot.  */
17429                                                       return 2411;
17430                                                     }
17431                                                 }
17432                                               else
17433                                                 {
17434                                                   /* 33222222222211111111110000000000
17435                                                      10987654321098765432109876543210
17436                                                      xx101110xx0xxxxx100x11xxxxxxxxxx
17437                                                      sqrdmlsh.  */
17438                                                   return 371;
17439                                                 }
17440                                             }
17441                                           else
17442                                             {
17443                                               /* 33222222222211111111110000000000
17444                                                  10987654321098765432109876543210
17445                                                  xx101110xx0xxxxx110xx1xxxxxxxxxx
17446                                                  fcmla.  */
17447                                               return 372;
17448                                             }
17449                                         }
17450                                       else
17451                                         {
17452                                           if (((word >> 11) & 0x1) == 0)
17453                                             {
17454                                               if (((word >> 14) & 0x1) == 0)
17455                                                 {
17456                                                   /* 33222222222211111111110000000000
17457                                                      10987654321098765432109876543210
17458                                                      xx101110xx0xxxxx101x01xxxxxxxxxx
17459                                                      ummla.  */
17460                                                   return 2487;
17461                                                 }
17462                                               else
17463                                                 {
17464                                                   /* 33222222222211111111110000000000
17465                                                      10987654321098765432109876543210
17466                                                      xx101110xx0xxxxx111x01xxxxxxxxxx
17467                                                      fcadd.  */
17468                                                   return 373;
17469                                                 }
17470                                             }
17471                                           else
17472                                             {
17473                                               if (((word >> 12) & 0x1) == 0)
17474                                                 {
17475                                                   /* 33222222222211111111110000000000
17476                                                      10987654321098765432109876543210
17477                                                      xx101110xx0xxxxx1x1011xxxxxxxxxx
17478                                                      bfmmla.  */
17479                                                   return 2503;
17480                                                 }
17481                                               else
17482                                                 {
17483                                                   if (((word >> 23) & 0x1) == 0)
17484                                                     {
17485                                                       /* 33222222222211111111110000000000
17486                                                          10987654321098765432109876543210
17487                                                          xx1011100x0xxxxx1x1111xxxxxxxxxx
17488                                                          bfdot.  */
17489                                                       return 2501;
17490                                                     }
17491                                                   else
17492                                                     {
17493                                                       if (((word >> 30) & 0x1) == 0)
17494                                                         {
17495                                                           /* 33222222222211111111110000000000
17496                                                              10987654321098765432109876543210
17497                                                              x01011101x0xxxxx1x1111xxxxxxxxxx
17498                                                              bfmlalb.  */
17499                                                           return 2508;
17500                                                         }
17501                                                       else
17502                                                         {
17503                                                           /* 33222222222211111111110000000000
17504                                                              10987654321098765432109876543210
17505                                                              x11011101x0xxxxx1x1111xxxxxxxxxx
17506                                                              bfmlalt.  */
17507                                                           return 2507;
17508                                                         }
17509                                                     }
17510                                                 }
17511                                             }
17512                                         }
17513                                     }
17514                                 }
17515                             }
17516                         }
17517                       else
17518                         {
17519                           if (((word >> 29) & 0x1) == 0)
17520                             {
17521                               if (((word >> 30) & 0x1) == 0)
17522                                 {
17523                                   if (((word >> 16) & 0x1) == 0)
17524                                     {
17525                                       if (((word >> 17) & 0x1) == 0)
17526                                         {
17527                                           /* 33222222222211111111110000000000
17528                                              10987654321098765432109876543210
17529                                              x0011110xx0xxx00xxxxxxxxxxxxxxxx
17530                                              fcvtzs.  */
17531                                           return 764;
17532                                         }
17533                                       else
17534                                         {
17535                                           /* 33222222222211111111110000000000
17536                                              10987654321098765432109876543210
17537                                              x0011110xx0xxx10xxxxxxxxxxxxxxxx
17538                                              scvtf.  */
17539                                           return 760;
17540                                         }
17541                                     }
17542                                   else
17543                                     {
17544                                       if (((word >> 17) & 0x1) == 0)
17545                                         {
17546                                           /* 33222222222211111111110000000000
17547                                              10987654321098765432109876543210
17548                                              x0011110xx0xxx01xxxxxxxxxxxxxxxx
17549                                              fcvtzu.  */
17550                                           return 766;
17551                                         }
17552                                       else
17553                                         {
17554                                           /* 33222222222211111111110000000000
17555                                              10987654321098765432109876543210
17556                                              x0011110xx0xxx11xxxxxxxxxxxxxxxx
17557                                              ucvtf.  */
17558                                           return 762;
17559                                         }
17560                                     }
17561                                 }
17562                               else
17563                                 {
17564                                   if (((word >> 10) & 0x1) == 0)
17565                                     {
17566                                       if (((word >> 12) & 0x1) == 0)
17567                                         {
17568                                           if (((word >> 13) & 0x1) == 0)
17569                                             {
17570                                               if (((word >> 14) & 0x1) == 0)
17571                                                 {
17572                                                   /* 33222222222211111111110000000000
17573                                                      10987654321098765432109876543210
17574                                                      x1011110xx0xxxxxx000x0xxxxxxxxxx
17575                                                      sha1c.  */
17576                                                   return 678;
17577                                                 }
17578                                               else
17579                                                 {
17580                                                   /* 33222222222211111111110000000000
17581                                                      10987654321098765432109876543210
17582                                                      x1011110xx0xxxxxx100x0xxxxxxxxxx
17583                                                      sha256h.  */
17584                                                   return 682;
17585                                                 }
17586                                             }
17587                                           else
17588                                             {
17589                                               if (((word >> 14) & 0x1) == 0)
17590                                                 {
17591                                                   /* 33222222222211111111110000000000
17592                                                      10987654321098765432109876543210
17593                                                      x1011110xx0xxxxxx010x0xxxxxxxxxx
17594                                                      sha1m.  */
17595                                                   return 680;
17596                                                 }
17597                                               else
17598                                                 {
17599                                                   /* 33222222222211111111110000000000
17600                                                      10987654321098765432109876543210
17601                                                      x1011110xx0xxxxxx110x0xxxxxxxxxx
17602                                                      sha256su1.  */
17603                                                   return 684;
17604                                                 }
17605                                             }
17606                                         }
17607                                       else
17608                                         {
17609                                           if (((word >> 13) & 0x1) == 0)
17610                                             {
17611                                               if (((word >> 14) & 0x1) == 0)
17612                                                 {
17613                                                   /* 33222222222211111111110000000000
17614                                                      10987654321098765432109876543210
17615                                                      x1011110xx0xxxxxx001x0xxxxxxxxxx
17616                                                      sha1p.  */
17617                                                   return 679;
17618                                                 }
17619                                               else
17620                                                 {
17621                                                   /* 33222222222211111111110000000000
17622                                                      10987654321098765432109876543210
17623                                                      x1011110xx0xxxxxx101x0xxxxxxxxxx
17624                                                      sha256h2.  */
17625                                                   return 683;
17626                                                 }
17627                                             }
17628                                           else
17629                                             {
17630                                               /* 33222222222211111111110000000000
17631                                                  10987654321098765432109876543210
17632                                                  x1011110xx0xxxxxxx11x0xxxxxxxxxx
17633                                                  sha1su0.  */
17634                                               return 681;
17635                                             }
17636                                         }
17637                                     }
17638                                   else
17639                                     {
17640                                       if (((word >> 11) & 0x1) == 0)
17641                                         {
17642                                           if (((word >> 13) & 0x1) == 0)
17643                                             {
17644                                               /* 33222222222211111111110000000000
17645                                                  10987654321098765432109876543210
17646                                                  x1011110xx0xxxxxxx0x01xxxxxxxxxx
17647                                                  dup.  */
17648                                               return 535;
17649                                             }
17650                                           else
17651                                             {
17652                                               /* 33222222222211111111110000000000
17653                                                  10987654321098765432109876543210
17654                                                  x1011110xx0xxxxxxx1x01xxxxxxxxxx
17655                                                  fcmeq.  */
17656                                               return 556;
17657                                             }
17658                                         }
17659                                       else
17660                                         {
17661                                           if (((word >> 13) & 0x1) == 0)
17662                                             {
17663                                               /* 33222222222211111111110000000000
17664                                                  10987654321098765432109876543210
17665                                                  x1011110xx0xxxxxxx0x11xxxxxxxxxx
17666                                                  fmulx.  */
17667                                               return 554;
17668                                             }
17669                                           else
17670                                             {
17671                                               if (((word >> 23) & 0x1) == 0)
17672                                                 {
17673                                                   /* 33222222222211111111110000000000
17674                                                      10987654321098765432109876543210
17675                                                      x10111100x0xxxxxxx1x11xxxxxxxxxx
17676                                                      frecps.  */
17677                                                   return 558;
17678                                                 }
17679                                               else
17680                                                 {
17681                                                   /* 33222222222211111111110000000000
17682                                                      10987654321098765432109876543210
17683                                                      x10111101x0xxxxxxx1x11xxxxxxxxxx
17684                                                      frsqrts.  */
17685                                                   return 560;
17686                                                 }
17687                                             }
17688                                         }
17689                                     }
17690                                 }
17691                             }
17692                           else
17693                             {
17694                               if (((word >> 11) & 0x1) == 0)
17695                                 {
17696                                   if (((word >> 12) & 0x1) == 0)
17697                                     {
17698                                       if (((word >> 13) & 0x1) == 0)
17699                                         {
17700                                           /* 33222222222211111111110000000000
17701                                              10987654321098765432109876543210
17702                                              xx111110xx0xxxxxxx000xxxxxxxxxxx
17703                                              sqrdmlah.  */
17704                                           return 588;
17705                                         }
17706                                       else
17707                                         {
17708                                           if (((word >> 23) & 0x1) == 0)
17709                                             {
17710                                               /* 33222222222211111111110000000000
17711                                                  10987654321098765432109876543210
17712                                                  xx1111100x0xxxxxxx100xxxxxxxxxxx
17713                                                  fcmge.  */
17714                                               return 573;
17715                                             }
17716                                           else
17717                                             {
17718                                               /* 33222222222211111111110000000000
17719                                                  10987654321098765432109876543210
17720                                                  xx1111101x0xxxxxxx100xxxxxxxxxxx
17721                                                  fcmgt.  */
17722                                               return 579;
17723                                             }
17724                                         }
17725                                     }
17726                                   else
17727                                     {
17728                                       /* 33222222222211111111110000000000
17729                                          10987654321098765432109876543210
17730                                          xx111110xx0xxxxxxxx10xxxxxxxxxxx
17731                                          fabd.  */
17732                                       return 577;
17733                                     }
17734                                 }
17735                               else
17736                                 {
17737                                   if (((word >> 13) & 0x1) == 0)
17738                                     {
17739                                       /* 33222222222211111111110000000000
17740                                          10987654321098765432109876543210
17741                                          xx111110xx0xxxxxxx0x1xxxxxxxxxxx
17742                                          sqrdmlsh.  */
17743                                       return 589;
17744                                     }
17745                                   else
17746                                     {
17747                                       if (((word >> 23) & 0x1) == 0)
17748                                         {
17749                                           /* 33222222222211111111110000000000
17750                                              10987654321098765432109876543210
17751                                              xx1111100x0xxxxxxx1x1xxxxxxxxxxx
17752                                              facge.  */
17753                                           return 575;
17754                                         }
17755                                       else
17756                                         {
17757                                           /* 33222222222211111111110000000000
17758                                              10987654321098765432109876543210
17759                                              xx1111101x0xxxxxxx1x1xxxxxxxxxxx
17760                                              facgt.  */
17761                                           return 581;
17762                                         }
17763                                     }
17764                                 }
17765                             }
17766                         }
17767                     }
17768                   else
17769                     {
17770                       if (((word >> 28) & 0x1) == 0)
17771                         {
17772                           if (((word >> 15) & 0x1) == 0)
17773                             {
17774                               if (((word >> 29) & 0x1) == 0)
17775                                 {
17776                                   if (((word >> 31) & 0x1) == 0)
17777                                     {
17778                                       if (((word >> 10) & 0x1) == 0)
17779                                         {
17780                                           if (((word >> 11) & 0x1) == 0)
17781                                             {
17782                                               if (((word >> 12) & 0x1) == 0)
17783                                                 {
17784                                                   if (((word >> 13) & 0x1) == 0)
17785                                                     {
17786                                                       if (((word >> 14) & 0x1) == 0)
17787                                                         {
17788                                                           if (((word >> 30) & 0x1) == 0)
17789                                                             {
17790                                                               /* 33222222222211111111110000000000
17791                                                                  10987654321098765432109876543210
17792                                                                  00001110xx1xxxxx000000xxxxxxxxxx
17793                                                                  saddl.  */
17794                                                               return 44;
17795                                                             }
17796                                                           else
17797                                                             {
17798                                                               /* 33222222222211111111110000000000
17799                                                                  10987654321098765432109876543210
17800                                                                  01001110xx1xxxxx000000xxxxxxxxxx
17801                                                                  saddl2.  */
17802                                                               return 45;
17803                                                             }
17804                                                         }
17805                                                       else
17806                                                         {
17807                                                           if (((word >> 30) & 0x1) == 0)
17808                                                             {
17809                                                               /* 33222222222211111111110000000000
17810                                                                  10987654321098765432109876543210
17811                                                                  00001110xx1xxxxx010000xxxxxxxxxx
17812                                                                  addhn.  */
17813                                                               return 52;
17814                                                             }
17815                                                           else
17816                                                             {
17817                                                               /* 33222222222211111111110000000000
17818                                                                  10987654321098765432109876543210
17819                                                                  01001110xx1xxxxx010000xxxxxxxxxx
17820                                                                  addhn2.  */
17821                                                               return 53;
17822                                                             }
17823                                                         }
17824                                                     }
17825                                                   else
17826                                                     {
17827                                                       if (((word >> 14) & 0x1) == 0)
17828                                                         {
17829                                                           if (((word >> 30) & 0x1) == 0)
17830                                                             {
17831                                                               /* 33222222222211111111110000000000
17832                                                                  10987654321098765432109876543210
17833                                                                  00001110xx1xxxxx001000xxxxxxxxxx
17834                                                                  ssubl.  */
17835                                                               return 48;
17836                                                             }
17837                                                           else
17838                                                             {
17839                                                               /* 33222222222211111111110000000000
17840                                                                  10987654321098765432109876543210
17841                                                                  01001110xx1xxxxx001000xxxxxxxxxx
17842                                                                  ssubl2.  */
17843                                                               return 49;
17844                                                             }
17845                                                         }
17846                                                       else
17847                                                         {
17848                                                           if (((word >> 30) & 0x1) == 0)
17849                                                             {
17850                                                               /* 33222222222211111111110000000000
17851                                                                  10987654321098765432109876543210
17852                                                                  00001110xx1xxxxx011000xxxxxxxxxx
17853                                                                  subhn.  */
17854                                                               return 56;
17855                                                             }
17856                                                           else
17857                                                             {
17858                                                               /* 33222222222211111111110000000000
17859                                                                  10987654321098765432109876543210
17860                                                                  01001110xx1xxxxx011000xxxxxxxxxx
17861                                                                  subhn2.  */
17862                                                               return 57;
17863                                                             }
17864                                                         }
17865                                                     }
17866                                                 }
17867                                               else
17868                                                 {
17869                                                   if (((word >> 13) & 0x1) == 0)
17870                                                     {
17871                                                       if (((word >> 14) & 0x1) == 0)
17872                                                         {
17873                                                           if (((word >> 30) & 0x1) == 0)
17874                                                             {
17875                                                               /* 33222222222211111111110000000000
17876                                                                  10987654321098765432109876543210
17877                                                                  00001110xx1xxxxx000100xxxxxxxxxx
17878                                                                  saddw.  */
17879                                                               return 46;
17880                                                             }
17881                                                           else
17882                                                             {
17883                                                               /* 33222222222211111111110000000000
17884                                                                  10987654321098765432109876543210
17885                                                                  01001110xx1xxxxx000100xxxxxxxxxx
17886                                                                  saddw2.  */
17887                                                               return 47;
17888                                                             }
17889                                                         }
17890                                                       else
17891                                                         {
17892                                                           if (((word >> 30) & 0x1) == 0)
17893                                                             {
17894                                                               /* 33222222222211111111110000000000
17895                                                                  10987654321098765432109876543210
17896                                                                  00001110xx1xxxxx010100xxxxxxxxxx
17897                                                                  sabal.  */
17898                                                               return 54;
17899                                                             }
17900                                                           else
17901                                                             {
17902                                                               /* 33222222222211111111110000000000
17903                                                                  10987654321098765432109876543210
17904                                                                  01001110xx1xxxxx010100xxxxxxxxxx
17905                                                                  sabal2.  */
17906                                                               return 55;
17907                                                             }
17908                                                         }
17909                                                     }
17910                                                   else
17911                                                     {
17912                                                       if (((word >> 14) & 0x1) == 0)
17913                                                         {
17914                                                           if (((word >> 30) & 0x1) == 0)
17915                                                             {
17916                                                               /* 33222222222211111111110000000000
17917                                                                  10987654321098765432109876543210
17918                                                                  00001110xx1xxxxx001100xxxxxxxxxx
17919                                                                  ssubw.  */
17920                                                               return 50;
17921                                                             }
17922                                                           else
17923                                                             {
17924                                                               /* 33222222222211111111110000000000
17925                                                                  10987654321098765432109876543210
17926                                                                  01001110xx1xxxxx001100xxxxxxxxxx
17927                                                                  ssubw2.  */
17928                                                               return 51;
17929                                                             }
17930                                                         }
17931                                                       else
17932                                                         {
17933                                                           if (((word >> 30) & 0x1) == 0)
17934                                                             {
17935                                                               /* 33222222222211111111110000000000
17936                                                                  10987654321098765432109876543210
17937                                                                  00001110xx1xxxxx011100xxxxxxxxxx
17938                                                                  sabdl.  */
17939                                                               return 58;
17940                                                             }
17941                                                           else
17942                                                             {
17943                                                               /* 33222222222211111111110000000000
17944                                                                  10987654321098765432109876543210
17945                                                                  01001110xx1xxxxx011100xxxxxxxxxx
17946                                                                  sabdl2.  */
17947                                                               return 59;
17948                                                             }
17949                                                         }
17950                                                     }
17951                                                 }
17952                                             }
17953                                           else
17954                                             {
17955                                               if (((word >> 12) & 0x1) == 0)
17956                                                 {
17957                                                   if (((word >> 13) & 0x1) == 0)
17958                                                     {
17959                                                       if (((word >> 14) & 0x1) == 0)
17960                                                         {
17961                                                           /* 33222222222211111111110000000000
17962                                                              10987654321098765432109876543210
17963                                                              0x001110xx1xxxxx000010xxxxxxxxxx
17964                                                              rev64.  */
17965                                                           return 162;
17966                                                         }
17967                                                       else
17968                                                         {
17969                                                           if (((word >> 16) & 0x1) == 0)
17970                                                             {
17971                                                               if (((word >> 19) & 0x1) == 0)
17972                                                                 {
17973                                                                   /* 33222222222211111111110000000000
17974                                                                      10987654321098765432109876543210
17975                                                                      0x001110xx1x0xx0010010xxxxxxxxxx
17976                                                                      cls.  */
17977                                                                   return 166;
17978                                                                 }
17979                                                               else
17980                                                                 {
17981                                                                   /* 33222222222211111111110000000000
17982                                                                      10987654321098765432109876543210
17983                                                                      0x001110xx1x1xx0010010xxxxxxxxxx
17984                                                                      aese.  */
17985                                                                   return 671;
17986                                                                 }
17987                                                             }
17988                                                           else
17989                                                             {
17990                                                               if (((word >> 30) & 0x1) == 0)
17991                                                                 {
17992                                                                   /* 33222222222211111111110000000000
17993                                                                      10987654321098765432109876543210
17994                                                                      00001110xx1xxxx1010010xxxxxxxxxx
17995                                                                      sqxtn.  */
17996                                                                   return 176;
17997                                                                 }
17998                                                               else
17999                                                                 {
18000                                                                   /* 33222222222211111111110000000000
18001                                                                      10987654321098765432109876543210
18002                                                                      01001110xx1xxxx1010010xxxxxxxxxx
18003                                                                      sqxtn2.  */
18004                                                                   return 177;
18005                                                                 }
18006                                                             }
18007                                                         }
18008                                                     }
18009                                                   else
18010                                                     {
18011                                                       if (((word >> 14) & 0x1) == 0)
18012                                                         {
18013                                                           if (((word >> 16) & 0x1) == 0)
18014                                                             {
18015                                                               /* 33222222222211111111110000000000
18016                                                                  10987654321098765432109876543210
18017                                                                  0x001110xx1xxxx0001010xxxxxxxxxx
18018                                                                  saddlp.  */
18019                                                               return 164;
18020                                                             }
18021                                                           else
18022                                                             {
18023                                                               if (((word >> 30) & 0x1) == 0)
18024                                                                 {
18025                                                                   /* 33222222222211111111110000000000
18026                                                                      10987654321098765432109876543210
18027                                                                      00001110xx1xxxx1001010xxxxxxxxxx
18028                                                                      xtn.  */
18029                                                                   return 174;
18030                                                                 }
18031                                                               else
18032                                                                 {
18033                                                                   /* 33222222222211111111110000000000
18034                                                                      10987654321098765432109876543210
18035                                                                      01001110xx1xxxx1001010xxxxxxxxxx
18036                                                                      xtn2.  */
18037                                                                   return 175;
18038                                                                 }
18039                                                             }
18040                                                         }
18041                                                       else
18042                                                         {
18043                                                           if (((word >> 16) & 0x1) == 0)
18044                                                             {
18045                                                               if (((word >> 19) & 0x1) == 0)
18046                                                                 {
18047                                                                   /* 33222222222211111111110000000000
18048                                                                      10987654321098765432109876543210
18049                                                                      0x001110xx1x0xx0011010xxxxxxxxxx
18050                                                                      sadalp.  */
18051                                                                   return 168;
18052                                                                 }
18053                                                               else
18054                                                                 {
18055                                                                   /* 33222222222211111111110000000000
18056                                                                      10987654321098765432109876543210
18057                                                                      0x001110xx1x1xx0011010xxxxxxxxxx
18058                                                                      aesmc.  */
18059                                                                   return 673;
18060                                                                 }
18061                                                             }
18062                                                           else
18063                                                             {
18064                                                               if (((word >> 23) & 0x1) == 0)
18065                                                                 {
18066                                                                   if (((word >> 30) & 0x1) == 0)
18067                                                                     {
18068                                                                       /* 33222222222211111111110000000000
18069                                                                          10987654321098765432109876543210
18070                                                                          000011100x1xxxx1011010xxxxxxxxxx
18071                                                                          fcvtn.  */
18072                                                                       return 178;
18073                                                                     }
18074                                                                   else
18075                                                                     {
18076                                                                       /* 33222222222211111111110000000000
18077                                                                          10987654321098765432109876543210
18078                                                                          010011100x1xxxx1011010xxxxxxxxxx
18079                                                                          fcvtn2.  */
18080                                                                       return 179;
18081                                                                     }
18082                                                                 }
18083                                                               else
18084                                                                 {
18085                                                                   if (((word >> 30) & 0x1) == 0)
18086                                                                     {
18087                                                                       /* 33222222222211111111110000000000
18088                                                                          10987654321098765432109876543210
18089                                                                          000011101x1xxxx1011010xxxxxxxxxx
18090                                                                          bfcvtn.  */
18091                                                                       return 2504;
18092                                                                     }
18093                                                                   else
18094                                                                     {
18095                                                                       /* 33222222222211111111110000000000
18096                                                                          10987654321098765432109876543210
18097                                                                          010011101x1xxxx1011010xxxxxxxxxx
18098                                                                          bfcvtn2.  */
18099                                                                       return 2505;
18100                                                                     }
18101                                                                 }
18102                                                             }
18103                                                         }
18104                                                     }
18105                                                 }
18106                                               else
18107                                                 {
18108                                                   if (((word >> 13) & 0x1) == 0)
18109                                                     {
18110                                                       if (((word >> 14) & 0x1) == 0)
18111                                                         {
18112                                                           /* 33222222222211111111110000000000
18113                                                              10987654321098765432109876543210
18114                                                              0x001110xx1xxxxx000110xxxxxxxxxx
18115                                                              rev16.  */
18116                                                           return 163;
18117                                                         }
18118                                                       else
18119                                                         {
18120                                                           if (((word >> 19) & 0x1) == 0)
18121                                                             {
18122                                                               /* 33222222222211111111110000000000
18123                                                                  10987654321098765432109876543210
18124                                                                  0x001110xx1x0xxx010110xxxxxxxxxx
18125                                                                  cnt.  */
18126                                                               return 167;
18127                                                             }
18128                                                           else
18129                                                             {
18130                                                               /* 33222222222211111111110000000000
18131                                                                  10987654321098765432109876543210
18132                                                                  0x001110xx1x1xxx010110xxxxxxxxxx
18133                                                                  aesd.  */
18134                                                               return 672;
18135                                                             }
18136                                                         }
18137                                                     }
18138                                                   else
18139                                                     {
18140                                                       if (((word >> 14) & 0x1) == 0)
18141                                                         {
18142                                                           if (((word >> 20) & 0x1) == 0)
18143                                                             {
18144                                                               /* 33222222222211111111110000000000
18145                                                                  10987654321098765432109876543210
18146                                                                  0x001110xx10xxxx001110xxxxxxxxxx
18147                                                                  suqadd.  */
18148                                                               return 165;
18149                                                             }
18150                                                           else
18151                                                             {
18152                                                               /* 33222222222211111111110000000000
18153                                                                  10987654321098765432109876543210
18154                                                                  0x001110xx11xxxx001110xxxxxxxxxx
18155                                                                  saddlv.  */
18156                                                               return 29;
18157                                                             }
18158                                                         }
18159                                                       else
18160                                                         {
18161                                                           if (((word >> 16) & 0x1) == 0)
18162                                                             {
18163                                                               if (((word >> 19) & 0x1) == 0)
18164                                                                 {
18165                                                                   /* 33222222222211111111110000000000
18166                                                                      10987654321098765432109876543210
18167                                                                      0x001110xx1x0xx0011110xxxxxxxxxx
18168                                                                      sqabs.  */
18169                                                                   return 169;
18170                                                                 }
18171                                                               else
18172                                                                 {
18173                                                                   /* 33222222222211111111110000000000
18174                                                                      10987654321098765432109876543210
18175                                                                      0x001110xx1x1xx0011110xxxxxxxxxx
18176                                                                      aesimc.  */
18177                                                                   return 674;
18178                                                                 }
18179                                                             }
18180                                                           else
18181                                                             {
18182                                                               if (((word >> 30) & 0x1) == 0)
18183                                                                 {
18184                                                                   /* 33222222222211111111110000000000
18185                                                                      10987654321098765432109876543210
18186                                                                      00001110xx1xxxx1011110xxxxxxxxxx
18187                                                                      fcvtl.  */
18188                                                                   return 180;
18189                                                                 }
18190                                                               else
18191                                                                 {
18192                                                                   /* 33222222222211111111110000000000
18193                                                                      10987654321098765432109876543210
18194                                                                      01001110xx1xxxx1011110xxxxxxxxxx
18195                                                                      fcvtl2.  */
18196                                                                   return 181;
18197                                                                 }
18198                                                             }
18199                                                         }
18200                                                     }
18201                                                 }
18202                                             }
18203                                         }
18204                                       else
18205                                         {
18206                                           if (((word >> 11) & 0x1) == 0)
18207                                             {
18208                                               if (((word >> 12) & 0x1) == 0)
18209                                                 {
18210                                                   if (((word >> 13) & 0x1) == 0)
18211                                                     {
18212                                                       if (((word >> 14) & 0x1) == 0)
18213                                                         {
18214                                                           /* 33222222222211111111110000000000
18215                                                              10987654321098765432109876543210
18216                                                              0x001110xx1xxxxx000001xxxxxxxxxx
18217                                                              shadd.  */
18218                                                           return 268;
18219                                                         }
18220                                                       else
18221                                                         {
18222                                                           /* 33222222222211111111110000000000
18223                                                              10987654321098765432109876543210
18224                                                              0x001110xx1xxxxx010001xxxxxxxxxx
18225                                                              sshl.  */
18226                                                           return 275;
18227                                                         }
18228                                                     }
18229                                                   else
18230                                                     {
18231                                                       if (((word >> 14) & 0x1) == 0)
18232                                                         {
18233                                                           /* 33222222222211111111110000000000
18234                                                              10987654321098765432109876543210
18235                                                              0x001110xx1xxxxx001001xxxxxxxxxx
18236                                                              shsub.  */
18237                                                           return 271;
18238                                                         }
18239                                                       else
18240                                                         {
18241                                                           /* 33222222222211111111110000000000
18242                                                              10987654321098765432109876543210
18243                                                              0x001110xx1xxxxx011001xxxxxxxxxx
18244                                                              smax.  */
18245                                                           return 279;
18246                                                         }
18247                                                     }
18248                                                 }
18249                                               else
18250                                                 {
18251                                                   if (((word >> 13) & 0x1) == 0)
18252                                                     {
18253                                                       if (((word >> 14) & 0x1) == 0)
18254                                                         {
18255                                                           /* 33222222222211111111110000000000
18256                                                              10987654321098765432109876543210
18257                                                              0x001110xx1xxxxx000101xxxxxxxxxx
18258                                                              srhadd.  */
18259                                                           return 270;
18260                                                         }
18261                                                       else
18262                                                         {
18263                                                           /* 33222222222211111111110000000000
18264                                                              10987654321098765432109876543210
18265                                                              0x001110xx1xxxxx010101xxxxxxxxxx
18266                                                              srshl.  */
18267                                                           return 277;
18268                                                         }
18269                                                     }
18270                                                   else
18271                                                     {
18272                                                       if (((word >> 14) & 0x1) == 0)
18273                                                         {
18274                                                           /* 33222222222211111111110000000000
18275                                                              10987654321098765432109876543210
18276                                                              0x001110xx1xxxxx001101xxxxxxxxxx
18277                                                              cmgt.  */
18278                                                           return 273;
18279                                                         }
18280                                                       else
18281                                                         {
18282                                                           /* 33222222222211111111110000000000
18283                                                              10987654321098765432109876543210
18284                                                              0x001110xx1xxxxx011101xxxxxxxxxx
18285                                                              sabd.  */
18286                                                           return 281;
18287                                                         }
18288                                                     }
18289                                                 }
18290                                             }
18291                                           else
18292                                             {
18293                                               if (((word >> 12) & 0x1) == 0)
18294                                                 {
18295                                                   if (((word >> 13) & 0x1) == 0)
18296                                                     {
18297                                                       if (((word >> 14) & 0x1) == 0)
18298                                                         {
18299                                                           /* 33222222222211111111110000000000
18300                                                              10987654321098765432109876543210
18301                                                              0x001110xx1xxxxx000011xxxxxxxxxx
18302                                                              sqadd.  */
18303                                                           return 269;
18304                                                         }
18305                                                       else
18306                                                         {
18307                                                           /* 33222222222211111111110000000000
18308                                                              10987654321098765432109876543210
18309                                                              0x001110xx1xxxxx010011xxxxxxxxxx
18310                                                              sqshl.  */
18311                                                           return 276;
18312                                                         }
18313                                                     }
18314                                                   else
18315                                                     {
18316                                                       if (((word >> 14) & 0x1) == 0)
18317                                                         {
18318                                                           /* 33222222222211111111110000000000
18319                                                              10987654321098765432109876543210
18320                                                              0x001110xx1xxxxx001011xxxxxxxxxx
18321                                                              sqsub.  */
18322                                                           return 272;
18323                                                         }
18324                                                       else
18325                                                         {
18326                                                           /* 33222222222211111111110000000000
18327                                                              10987654321098765432109876543210
18328                                                              0x001110xx1xxxxx011011xxxxxxxxxx
18329                                                              smin.  */
18330                                                           return 280;
18331                                                         }
18332                                                     }
18333                                                 }
18334                                               else
18335                                                 {
18336                                                   if (((word >> 13) & 0x1) == 0)
18337                                                     {
18338                                                       if (((word >> 14) & 0x1) == 0)
18339                                                         {
18340                                                           if (((word >> 22) & 0x1) == 0)
18341                                                             {
18342                                                               if (((word >> 23) & 0x1) == 0)
18343                                                                 {
18344                                                                   /* 33222222222211111111110000000000
18345                                                                      10987654321098765432109876543210
18346                                                                      0x001110001xxxxx000111xxxxxxxxxx
18347                                                                      and.  */
18348                                                                   return 305;
18349                                                                 }
18350                                                               else
18351                                                                 {
18352                                                                   /* 33222222222211111111110000000000
18353                                                                      10987654321098765432109876543210
18354                                                                      0x001110101xxxxx000111xxxxxxxxxx
18355                                                                      orr.  */
18356                                                                   return 317;
18357                                                                 }
18358                                                             }
18359                                                           else
18360                                                             {
18361                                                               if (((word >> 23) & 0x1) == 0)
18362                                                                 {
18363                                                                   /* 33222222222211111111110000000000
18364                                                                      10987654321098765432109876543210
18365                                                                      0x001110011xxxxx000111xxxxxxxxxx
18366                                                                      bic.  */
18367                                                                   return 306;
18368                                                                 }
18369                                                               else
18370                                                                 {
18371                                                                   /* 33222222222211111111110000000000
18372                                                                      10987654321098765432109876543210
18373                                                                      0x001110111xxxxx000111xxxxxxxxxx
18374                                                                      orn.  */
18375                                                                   return 319;
18376                                                                 }
18377                                                             }
18378                                                         }
18379                                                       else
18380                                                         {
18381                                                           /* 33222222222211111111110000000000
18382                                                              10987654321098765432109876543210
18383                                                              0x001110xx1xxxxx010111xxxxxxxxxx
18384                                                              sqrshl.  */
18385                                                           return 278;
18386                                                         }
18387                                                     }
18388                                                   else
18389                                                     {
18390                                                       if (((word >> 14) & 0x1) == 0)
18391                                                         {
18392                                                           /* 33222222222211111111110000000000
18393                                                              10987654321098765432109876543210
18394                                                              0x001110xx1xxxxx001111xxxxxxxxxx
18395                                                              cmge.  */
18396                                                           return 274;
18397                                                         }
18398                                                       else
18399                                                         {
18400                                                           /* 33222222222211111111110000000000
18401                                                              10987654321098765432109876543210
18402                                                              0x001110xx1xxxxx011111xxxxxxxxxx
18403                                                              saba.  */
18404                                                           return 282;
18405                                                         }
18406                                                     }
18407                                                 }
18408                                             }
18409                                         }
18410                                     }
18411                                   else
18412                                     {
18413                                       /* 33222222222211111111110000000000
18414                                          10987654321098765432109876543210
18415                                          1x001110xx1xxxxx0xxxxxxxxxxxxxxx
18416                                          bcax.  */
18417                                       return 2422;
18418                                     }
18419                                 }
18420                               else
18421                                 {
18422                                   if (((word >> 10) & 0x1) == 0)
18423                                     {
18424                                       if (((word >> 11) & 0x1) == 0)
18425                                         {
18426                                           if (((word >> 12) & 0x1) == 0)
18427                                             {
18428                                               if (((word >> 13) & 0x1) == 0)
18429                                                 {
18430                                                   if (((word >> 14) & 0x1) == 0)
18431                                                     {
18432                                                       if (((word >> 30) & 0x1) == 0)
18433                                                         {
18434                                                           /* 33222222222211111111110000000000
18435                                                              10987654321098765432109876543210
18436                                                              x0101110xx1xxxxx000000xxxxxxxxxx
18437                                                              uaddl.  */
18438                                                           return 76;
18439                                                         }
18440                                                       else
18441                                                         {
18442                                                           /* 33222222222211111111110000000000
18443                                                              10987654321098765432109876543210
18444                                                              x1101110xx1xxxxx000000xxxxxxxxxx
18445                                                              uaddl2.  */
18446                                                           return 77;
18447                                                         }
18448                                                     }
18449                                                   else
18450                                                     {
18451                                                       if (((word >> 30) & 0x1) == 0)
18452                                                         {
18453                                                           /* 33222222222211111111110000000000
18454                                                              10987654321098765432109876543210
18455                                                              x0101110xx1xxxxx010000xxxxxxxxxx
18456                                                              raddhn.  */
18457                                                           return 84;
18458                                                         }
18459                                                       else
18460                                                         {
18461                                                           /* 33222222222211111111110000000000
18462                                                              10987654321098765432109876543210
18463                                                              x1101110xx1xxxxx010000xxxxxxxxxx
18464                                                              raddhn2.  */
18465                                                           return 85;
18466                                                         }
18467                                                     }
18468                                                 }
18469                                               else
18470                                                 {
18471                                                   if (((word >> 14) & 0x1) == 0)
18472                                                     {
18473                                                       if (((word >> 30) & 0x1) == 0)
18474                                                         {
18475                                                           /* 33222222222211111111110000000000
18476                                                              10987654321098765432109876543210
18477                                                              x0101110xx1xxxxx001000xxxxxxxxxx
18478                                                              usubl.  */
18479                                                           return 80;
18480                                                         }
18481                                                       else
18482                                                         {
18483                                                           /* 33222222222211111111110000000000
18484                                                              10987654321098765432109876543210
18485                                                              x1101110xx1xxxxx001000xxxxxxxxxx
18486                                                              usubl2.  */
18487                                                           return 81;
18488                                                         }
18489                                                     }
18490                                                   else
18491                                                     {
18492                                                       if (((word >> 30) & 0x1) == 0)
18493                                                         {
18494                                                           /* 33222222222211111111110000000000
18495                                                              10987654321098765432109876543210
18496                                                              x0101110xx1xxxxx011000xxxxxxxxxx
18497                                                              rsubhn.  */
18498                                                           return 88;
18499                                                         }
18500                                                       else
18501                                                         {
18502                                                           /* 33222222222211111111110000000000
18503                                                              10987654321098765432109876543210
18504                                                              x1101110xx1xxxxx011000xxxxxxxxxx
18505                                                              rsubhn2.  */
18506                                                           return 89;
18507                                                         }
18508                                                     }
18509                                                 }
18510                                             }
18511                                           else
18512                                             {
18513                                               if (((word >> 13) & 0x1) == 0)
18514                                                 {
18515                                                   if (((word >> 14) & 0x1) == 0)
18516                                                     {
18517                                                       if (((word >> 30) & 0x1) == 0)
18518                                                         {
18519                                                           /* 33222222222211111111110000000000
18520                                                              10987654321098765432109876543210
18521                                                              x0101110xx1xxxxx000100xxxxxxxxxx
18522                                                              uaddw.  */
18523                                                           return 78;
18524                                                         }
18525                                                       else
18526                                                         {
18527                                                           /* 33222222222211111111110000000000
18528                                                              10987654321098765432109876543210
18529                                                              x1101110xx1xxxxx000100xxxxxxxxxx
18530                                                              uaddw2.  */
18531                                                           return 79;
18532                                                         }
18533                                                     }
18534                                                   else
18535                                                     {
18536                                                       if (((word >> 30) & 0x1) == 0)
18537                                                         {
18538                                                           /* 33222222222211111111110000000000
18539                                                              10987654321098765432109876543210
18540                                                              x0101110xx1xxxxx010100xxxxxxxxxx
18541                                                              uabal.  */
18542                                                           return 86;
18543                                                         }
18544                                                       else
18545                                                         {
18546                                                           /* 33222222222211111111110000000000
18547                                                              10987654321098765432109876543210
18548                                                              x1101110xx1xxxxx010100xxxxxxxxxx
18549                                                              uabal2.  */
18550                                                           return 87;
18551                                                         }
18552                                                     }
18553                                                 }
18554                                               else
18555                                                 {
18556                                                   if (((word >> 14) & 0x1) == 0)
18557                                                     {
18558                                                       if (((word >> 30) & 0x1) == 0)
18559                                                         {
18560                                                           /* 33222222222211111111110000000000
18561                                                              10987654321098765432109876543210
18562                                                              x0101110xx1xxxxx001100xxxxxxxxxx
18563                                                              usubw.  */
18564                                                           return 82;
18565                                                         }
18566                                                       else
18567                                                         {
18568                                                           /* 33222222222211111111110000000000
18569                                                              10987654321098765432109876543210
18570                                                              x1101110xx1xxxxx001100xxxxxxxxxx
18571                                                              usubw2.  */
18572                                                           return 83;
18573                                                         }
18574                                                     }
18575                                                   else
18576                                                     {
18577                                                       if (((word >> 30) & 0x1) == 0)
18578                                                         {
18579                                                           /* 33222222222211111111110000000000
18580                                                              10987654321098765432109876543210
18581                                                              x0101110xx1xxxxx011100xxxxxxxxxx
18582                                                              uabdl.  */
18583                                                           return 90;
18584                                                         }
18585                                                       else
18586                                                         {
18587                                                           /* 33222222222211111111110000000000
18588                                                              10987654321098765432109876543210
18589                                                              x1101110xx1xxxxx011100xxxxxxxxxx
18590                                                              uabdl2.  */
18591                                                           return 91;
18592                                                         }
18593                                                     }
18594                                                 }
18595                                             }
18596                                         }
18597                                       else
18598                                         {
18599                                           if (((word >> 12) & 0x1) == 0)
18600                                             {
18601                                               if (((word >> 13) & 0x1) == 0)
18602                                                 {
18603                                                   if (((word >> 14) & 0x1) == 0)
18604                                                     {
18605                                                       /* 33222222222211111111110000000000
18606                                                          10987654321098765432109876543210
18607                                                          xx101110xx1xxxxx000010xxxxxxxxxx
18608                                                          rev32.  */
18609                                                       return 213;
18610                                                     }
18611                                                   else
18612                                                     {
18613                                                       if (((word >> 16) & 0x1) == 0)
18614                                                         {
18615                                                           /* 33222222222211111111110000000000
18616                                                              10987654321098765432109876543210
18617                                                              xx101110xx1xxxx0010010xxxxxxxxxx
18618                                                              clz.  */
18619                                                           return 216;
18620                                                         }
18621                                                       else
18622                                                         {
18623                                                           if (((word >> 30) & 0x1) == 0)
18624                                                             {
18625                                                               /* 33222222222211111111110000000000
18626                                                                  10987654321098765432109876543210
18627                                                                  x0101110xx1xxxx1010010xxxxxxxxxx
18628                                                                  uqxtn.  */
18629                                                               return 226;
18630                                                             }
18631                                                           else
18632                                                             {
18633                                                               /* 33222222222211111111110000000000
18634                                                                  10987654321098765432109876543210
18635                                                                  x1101110xx1xxxx1010010xxxxxxxxxx
18636                                                                  uqxtn2.  */
18637                                                               return 227;
18638                                                             }
18639                                                         }
18640                                                     }
18641                                                 }
18642                                               else
18643                                                 {
18644                                                   if (((word >> 14) & 0x1) == 0)
18645                                                     {
18646                                                       if (((word >> 16) & 0x1) == 0)
18647                                                         {
18648                                                           /* 33222222222211111111110000000000
18649                                                              10987654321098765432109876543210
18650                                                              xx101110xx1xxxx0001010xxxxxxxxxx
18651                                                              uaddlp.  */
18652                                                           return 214;
18653                                                         }
18654                                                       else
18655                                                         {
18656                                                           if (((word >> 30) & 0x1) == 0)
18657                                                             {
18658                                                               /* 33222222222211111111110000000000
18659                                                                  10987654321098765432109876543210
18660                                                                  x0101110xx1xxxx1001010xxxxxxxxxx
18661                                                                  sqxtun.  */
18662                                                               return 222;
18663                                                             }
18664                                                           else
18665                                                             {
18666                                                               /* 33222222222211111111110000000000
18667                                                                  10987654321098765432109876543210
18668                                                                  x1101110xx1xxxx1001010xxxxxxxxxx
18669                                                                  sqxtun2.  */
18670                                                               return 223;
18671                                                             }
18672                                                         }
18673                                                     }
18674                                                   else
18675                                                     {
18676                                                       if (((word >> 16) & 0x1) == 0)
18677                                                         {
18678                                                           /* 33222222222211111111110000000000
18679                                                              10987654321098765432109876543210
18680                                                              xx101110xx1xxxx0011010xxxxxxxxxx
18681                                                              uadalp.  */
18682                                                           return 217;
18683                                                         }
18684                                                       else
18685                                                         {
18686                                                           if (((word >> 30) & 0x1) == 0)
18687                                                             {
18688                                                               /* 33222222222211111111110000000000
18689                                                                  10987654321098765432109876543210
18690                                                                  x0101110xx1xxxx1011010xxxxxxxxxx
18691                                                                  fcvtxn.  */
18692                                                               return 228;
18693                                                             }
18694                                                           else
18695                                                             {
18696                                                               /* 33222222222211111111110000000000
18697                                                                  10987654321098765432109876543210
18698                                                                  x1101110xx1xxxx1011010xxxxxxxxxx
18699                                                                  fcvtxn2.  */
18700                                                               return 229;
18701                                                             }
18702                                                         }
18703                                                     }
18704                                                 }
18705                                             }
18706                                           else
18707                                             {
18708                                               if (((word >> 13) & 0x1) == 0)
18709                                                 {
18710                                                   if (((word >> 22) & 0x1) == 0)
18711                                                     {
18712                                                       /* 33222222222211111111110000000000
18713                                                          10987654321098765432109876543210
18714                                                          xx101110x01xxxxx0x0110xxxxxxxxxx
18715                                                          not.  */
18716                                                       return 242;
18717                                                     }
18718                                                   else
18719                                                     {
18720                                                       /* 33222222222211111111110000000000
18721                                                          10987654321098765432109876543210
18722                                                          xx101110x11xxxxx0x0110xxxxxxxxxx
18723                                                          rbit.  */
18724                                                       return 244;
18725                                                     }
18726                                                 }
18727                                               else
18728                                                 {
18729                                                   if (((word >> 14) & 0x1) == 0)
18730                                                     {
18731                                                       if (((word >> 16) & 0x1) == 0)
18732                                                         {
18733                                                           if (((word >> 20) & 0x1) == 0)
18734                                                             {
18735                                                               /* 33222222222211111111110000000000
18736                                                                  10987654321098765432109876543210
18737                                                                  xx101110xx10xxx0001110xxxxxxxxxx
18738                                                                  usqadd.  */
18739                                                               return 215;
18740                                                             }
18741                                                           else
18742                                                             {
18743                                                               /* 33222222222211111111110000000000
18744                                                                  10987654321098765432109876543210
18745                                                                  xx101110xx11xxx0001110xxxxxxxxxx
18746                                                                  uaddlv.  */
18747                                                               return 33;
18748                                                             }
18749                                                         }
18750                                                       else
18751                                                         {
18752                                                           if (((word >> 30) & 0x1) == 0)
18753                                                             {
18754                                                               /* 33222222222211111111110000000000
18755                                                                  10987654321098765432109876543210
18756                                                                  x0101110xx1xxxx1001110xxxxxxxxxx
18757                                                                  shll.  */
18758                                                               return 224;
18759                                                             }
18760                                                           else
18761                                                             {
18762                                                               /* 33222222222211111111110000000000
18763                                                                  10987654321098765432109876543210
18764                                                                  x1101110xx1xxxx1001110xxxxxxxxxx
18765                                                                  shll2.  */
18766                                                               return 225;
18767                                                             }
18768                                                         }
18769                                                     }
18770                                                   else
18771                                                     {
18772                                                       /* 33222222222211111111110000000000
18773                                                          10987654321098765432109876543210
18774                                                          xx101110xx1xxxxx011110xxxxxxxxxx
18775                                                          sqneg.  */
18776                                                       return 218;
18777                                                     }
18778                                                 }
18779                                             }
18780                                         }
18781                                     }
18782                                   else
18783                                     {
18784                                       if (((word >> 11) & 0x1) == 0)
18785                                         {
18786                                           if (((word >> 12) & 0x1) == 0)
18787                                             {
18788                                               if (((word >> 13) & 0x1) == 0)
18789                                                 {
18790                                                   if (((word >> 14) & 0x1) == 0)
18791                                                     {
18792                                                       /* 33222222222211111111110000000000
18793                                                          10987654321098765432109876543210
18794                                                          xx101110xx1xxxxx000001xxxxxxxxxx
18795                                                          uhadd.  */
18796                                                       return 320;
18797                                                     }
18798                                                   else
18799                                                     {
18800                                                       /* 33222222222211111111110000000000
18801                                                          10987654321098765432109876543210
18802                                                          xx101110xx1xxxxx010001xxxxxxxxxx
18803                                                          ushl.  */
18804                                                       return 327;
18805                                                     }
18806                                                 }
18807                                               else
18808                                                 {
18809                                                   if (((word >> 14) & 0x1) == 0)
18810                                                     {
18811                                                       /* 33222222222211111111110000000000
18812                                                          10987654321098765432109876543210
18813                                                          xx101110xx1xxxxx001001xxxxxxxxxx
18814                                                          uhsub.  */
18815                                                       return 323;
18816                                                     }
18817                                                   else
18818                                                     {
18819                                                       /* 33222222222211111111110000000000
18820                                                          10987654321098765432109876543210
18821                                                          xx101110xx1xxxxx011001xxxxxxxxxx
18822                                                          umax.  */
18823                                                       return 331;
18824                                                     }
18825                                                 }
18826                                             }
18827                                           else
18828                                             {
18829                                               if (((word >> 13) & 0x1) == 0)
18830                                                 {
18831                                                   if (((word >> 14) & 0x1) == 0)
18832                                                     {
18833                                                       /* 33222222222211111111110000000000
18834                                                          10987654321098765432109876543210
18835                                                          xx101110xx1xxxxx000101xxxxxxxxxx
18836                                                          urhadd.  */
18837                                                       return 322;
18838                                                     }
18839                                                   else
18840                                                     {
18841                                                       /* 33222222222211111111110000000000
18842                                                          10987654321098765432109876543210
18843                                                          xx101110xx1xxxxx010101xxxxxxxxxx
18844                                                          urshl.  */
18845                                                       return 329;
18846                                                     }
18847                                                 }
18848                                               else
18849                                                 {
18850                                                   if (((word >> 14) & 0x1) == 0)
18851                                                     {
18852                                                       /* 33222222222211111111110000000000
18853                                                          10987654321098765432109876543210
18854                                                          xx101110xx1xxxxx001101xxxxxxxxxx
18855                                                          cmhi.  */
18856                                                       return 325;
18857                                                     }
18858                                                   else
18859                                                     {
18860                                                       /* 33222222222211111111110000000000
18861                                                          10987654321098765432109876543210
18862                                                          xx101110xx1xxxxx011101xxxxxxxxxx
18863                                                          uabd.  */
18864                                                       return 333;
18865                                                     }
18866                                                 }
18867                                             }
18868                                         }
18869                                       else
18870                                         {
18871                                           if (((word >> 12) & 0x1) == 0)
18872                                             {
18873                                               if (((word >> 13) & 0x1) == 0)
18874                                                 {
18875                                                   if (((word >> 14) & 0x1) == 0)
18876                                                     {
18877                                                       /* 33222222222211111111110000000000
18878                                                          10987654321098765432109876543210
18879                                                          xx101110xx1xxxxx000011xxxxxxxxxx
18880                                                          uqadd.  */
18881                                                       return 321;
18882                                                     }
18883                                                   else
18884                                                     {
18885                                                       /* 33222222222211111111110000000000
18886                                                          10987654321098765432109876543210
18887                                                          xx101110xx1xxxxx010011xxxxxxxxxx
18888                                                          uqshl.  */
18889                                                       return 328;
18890                                                     }
18891                                                 }
18892                                               else
18893                                                 {
18894                                                   if (((word >> 14) & 0x1) == 0)
18895                                                     {
18896                                                       /* 33222222222211111111110000000000
18897                                                          10987654321098765432109876543210
18898                                                          xx101110xx1xxxxx001011xxxxxxxxxx
18899                                                          uqsub.  */
18900                                                       return 324;
18901                                                     }
18902                                                   else
18903                                                     {
18904                                                       /* 33222222222211111111110000000000
18905                                                          10987654321098765432109876543210
18906                                                          xx101110xx1xxxxx011011xxxxxxxxxx
18907                                                          umin.  */
18908                                                       return 332;
18909                                                     }
18910                                                 }
18911                                             }
18912                                           else
18913                                             {
18914                                               if (((word >> 13) & 0x1) == 0)
18915                                                 {
18916                                                   if (((word >> 14) & 0x1) == 0)
18917                                                     {
18918                                                       if (((word >> 22) & 0x1) == 0)
18919                                                         {
18920                                                           if (((word >> 23) & 0x1) == 0)
18921                                                             {
18922                                                               /* 33222222222211111111110000000000
18923                                                                  10987654321098765432109876543210
18924                                                                  xx101110001xxxxx000111xxxxxxxxxx
18925                                                                  eor.  */
18926                                                               return 356;
18927                                                             }
18928                                                           else
18929                                                             {
18930                                                               /* 33222222222211111111110000000000
18931                                                                  10987654321098765432109876543210
18932                                                                  xx101110101xxxxx000111xxxxxxxxxx
18933                                                                  bit.  */
18934                                                               return 368;
18935                                                             }
18936                                                         }
18937                                                       else
18938                                                         {
18939                                                           if (((word >> 23) & 0x1) == 0)
18940                                                             {
18941                                                               /* 33222222222211111111110000000000
18942                                                                  10987654321098765432109876543210
18943                                                                  xx101110011xxxxx000111xxxxxxxxxx
18944                                                                  bsl.  */
18945                                                               return 357;
18946                                                             }
18947                                                           else
18948                                                             {
18949                                                               /* 33222222222211111111110000000000
18950                                                                  10987654321098765432109876543210
18951                                                                  xx101110111xxxxx000111xxxxxxxxxx
18952                                                                  bif.  */
18953                                                               return 369;
18954                                                             }
18955                                                         }
18956                                                     }
18957                                                   else
18958                                                     {
18959                                                       /* 33222222222211111111110000000000
18960                                                          10987654321098765432109876543210
18961                                                          xx101110xx1xxxxx010111xxxxxxxxxx
18962                                                          uqrshl.  */
18963                                                       return 330;
18964                                                     }
18965                                                 }
18966                                               else
18967                                                 {
18968                                                   if (((word >> 14) & 0x1) == 0)
18969                                                     {
18970                                                       /* 33222222222211111111110000000000
18971                                                          10987654321098765432109876543210
18972                                                          xx101110xx1xxxxx001111xxxxxxxxxx
18973                                                          cmhs.  */
18974                                                       return 326;
18975                                                     }
18976                                                   else
18977                                                     {
18978                                                       /* 33222222222211111111110000000000
18979                                                          10987654321098765432109876543210
18980                                                          xx101110xx1xxxxx011111xxxxxxxxxx
18981                                                          uaba.  */
18982                                                       return 334;
18983                                                     }
18984                                                 }
18985                                             }
18986                                         }
18987                                     }
18988                                 }
18989                             }
18990                           else
18991                             {
18992                               if (((word >> 10) & 0x1) == 0)
18993                                 {
18994                                   if (((word >> 11) & 0x1) == 0)
18995                                     {
18996                                       if (((word >> 12) & 0x1) == 0)
18997                                         {
18998                                           if (((word >> 13) & 0x1) == 0)
18999                                             {
19000                                               if (((word >> 14) & 0x1) == 0)
19001                                                 {
19002                                                   if (((word >> 29) & 0x1) == 0)
19003                                                     {
19004                                                       if (((word >> 30) & 0x1) == 0)
19005                                                         {
19006                                                           /* 33222222222211111111110000000000
19007                                                              10987654321098765432109876543210
19008                                                              x0001110xx1xxxxx100000xxxxxxxxxx
19009                                                              smlal.  */
19010                                                           return 60;
19011                                                         }
19012                                                       else
19013                                                         {
19014                                                           if (((word >> 31) & 0x1) == 0)
19015                                                             {
19016                                                               /* 33222222222211111111110000000000
19017                                                                  10987654321098765432109876543210
19018                                                                  01001110xx1xxxxx100000xxxxxxxxxx
19019                                                                  smlal2.  */
19020                                                               return 61;
19021                                                             }
19022                                                           else
19023                                                             {
19024                                                               /* 33222222222211111111110000000000
19025                                                                  10987654321098765432109876543210
19026                                                                  11001110xx1xxxxx100000xxxxxxxxxx
19027                                                                  sha512h.  */
19028                                                               return 2415;
19029                                                             }
19030                                                         }
19031                                                     }
19032                                                   else
19033                                                     {
19034                                                       if (((word >> 30) & 0x1) == 0)
19035                                                         {
19036                                                           /* 33222222222211111111110000000000
19037                                                              10987654321098765432109876543210
19038                                                              x0101110xx1xxxxx100000xxxxxxxxxx
19039                                                              umlal.  */
19040                                                           return 92;
19041                                                         }
19042                                                       else
19043                                                         {
19044                                                           /* 33222222222211111111110000000000
19045                                                              10987654321098765432109876543210
19046                                                              x1101110xx1xxxxx100000xxxxxxxxxx
19047                                                              umlal2.  */
19048                                                           return 93;
19049                                                         }
19050                                                     }
19051                                                 }
19052                                               else
19053                                                 {
19054                                                   if (((word >> 29) & 0x1) == 0)
19055                                                     {
19056                                                       if (((word >> 30) & 0x1) == 0)
19057                                                         {
19058                                                           /* 33222222222211111111110000000000
19059                                                              10987654321098765432109876543210
19060                                                              x0001110xx1xxxxx110000xxxxxxxxxx
19061                                                              smull.  */
19062                                                           return 68;
19063                                                         }
19064                                                       else
19065                                                         {
19066                                                           if (((word >> 31) & 0x1) == 0)
19067                                                             {
19068                                                               /* 33222222222211111111110000000000
19069                                                                  10987654321098765432109876543210
19070                                                                  01001110xx1xxxxx110000xxxxxxxxxx
19071                                                                  smull2.  */
19072                                                               return 69;
19073                                                             }
19074                                                           else
19075                                                             {
19076                                                               /* 33222222222211111111110000000000
19077                                                                  10987654321098765432109876543210
19078                                                                  11001110xx1xxxxx110000xxxxxxxxxx
19079                                                                  sm3partw1.  */
19080                                                               return 2428;
19081                                                             }
19082                                                         }
19083                                                     }
19084                                                   else
19085                                                     {
19086                                                       if (((word >> 30) & 0x1) == 0)
19087                                                         {
19088                                                           /* 33222222222211111111110000000000
19089                                                              10987654321098765432109876543210
19090                                                              x0101110xx1xxxxx110000xxxxxxxxxx
19091                                                              umull.  */
19092                                                           return 96;
19093                                                         }
19094                                                       else
19095                                                         {
19096                                                           /* 33222222222211111111110000000000
19097                                                              10987654321098765432109876543210
19098                                                              x1101110xx1xxxxx110000xxxxxxxxxx
19099                                                              umull2.  */
19100                                                           return 97;
19101                                                         }
19102                                                     }
19103                                                 }
19104                                             }
19105                                           else
19106                                             {
19107                                               if (((word >> 14) & 0x1) == 0)
19108                                                 {
19109                                                   if (((word >> 29) & 0x1) == 0)
19110                                                     {
19111                                                       if (((word >> 30) & 0x1) == 0)
19112                                                         {
19113                                                           /* 33222222222211111111110000000000
19114                                                              10987654321098765432109876543210
19115                                                              x0001110xx1xxxxx101000xxxxxxxxxx
19116                                                              smlsl.  */
19117                                                           return 64;
19118                                                         }
19119                                                       else
19120                                                         {
19121                                                           /* 33222222222211111111110000000000
19122                                                              10987654321098765432109876543210
19123                                                              x1001110xx1xxxxx101000xxxxxxxxxx
19124                                                              smlsl2.  */
19125                                                           return 65;
19126                                                         }
19127                                                     }
19128                                                   else
19129                                                     {
19130                                                       if (((word >> 30) & 0x1) == 0)
19131                                                         {
19132                                                           /* 33222222222211111111110000000000
19133                                                              10987654321098765432109876543210
19134                                                              x0101110xx1xxxxx101000xxxxxxxxxx
19135                                                              umlsl.  */
19136                                                           return 94;
19137                                                         }
19138                                                       else
19139                                                         {
19140                                                           /* 33222222222211111111110000000000
19141                                                              10987654321098765432109876543210
19142                                                              x1101110xx1xxxxx101000xxxxxxxxxx
19143                                                              umlsl2.  */
19144                                                           return 95;
19145                                                         }
19146                                                     }
19147                                                 }
19148                                               else
19149                                                 {
19150                                                   if (((word >> 22) & 0x1) == 0)
19151                                                     {
19152                                                       if (((word >> 30) & 0x1) == 0)
19153                                                         {
19154                                                           /* 33222222222211111111110000000000
19155                                                              10987654321098765432109876543210
19156                                                              x0x01110x01xxxxx111000xxxxxxxxxx
19157                                                              pmull.  */
19158                                                           return 72;
19159                                                         }
19160                                                       else
19161                                                         {
19162                                                           /* 33222222222211111111110000000000
19163                                                              10987654321098765432109876543210
19164                                                              x1x01110x01xxxxx111000xxxxxxxxxx
19165                                                              pmull2.  */
19166                                                           return 74;
19167                                                         }
19168                                                     }
19169                                                   else
19170                                                     {
19171                                                       if (((word >> 30) & 0x1) == 0)
19172                                                         {
19173                                                           /* 33222222222211111111110000000000
19174                                                              10987654321098765432109876543210
19175                                                              x0x01110x11xxxxx111000xxxxxxxxxx
19176                                                              pmull.  */
19177                                                           return 73;
19178                                                         }
19179                                                       else
19180                                                         {
19181                                                           /* 33222222222211111111110000000000
19182                                                              10987654321098765432109876543210
19183                                                              x1x01110x11xxxxx111000xxxxxxxxxx
19184                                                              pmull2.  */
19185                                                           return 75;
19186                                                         }
19187                                                     }
19188                                                 }
19189                                             }
19190                                         }
19191                                       else
19192                                         {
19193                                           if (((word >> 13) & 0x1) == 0)
19194                                             {
19195                                               if (((word >> 14) & 0x1) == 0)
19196                                                 {
19197                                                   if (((word >> 30) & 0x1) == 0)
19198                                                     {
19199                                                       /* 33222222222211111111110000000000
19200                                                          10987654321098765432109876543210
19201                                                          x0x01110xx1xxxxx100100xxxxxxxxxx
19202                                                          sqdmlal.  */
19203                                                       return 62;
19204                                                     }
19205                                                   else
19206                                                     {
19207                                                       /* 33222222222211111111110000000000
19208                                                          10987654321098765432109876543210
19209                                                          x1x01110xx1xxxxx100100xxxxxxxxxx
19210                                                          sqdmlal2.  */
19211                                                       return 63;
19212                                                     }
19213                                                 }
19214                                               else
19215                                                 {
19216                                                   if (((word >> 30) & 0x1) == 0)
19217                                                     {
19218                                                       /* 33222222222211111111110000000000
19219                                                          10987654321098765432109876543210
19220                                                          x0x01110xx1xxxxx110100xxxxxxxxxx
19221                                                          sqdmull.  */
19222                                                       return 70;
19223                                                     }
19224                                                   else
19225                                                     {
19226                                                       /* 33222222222211111111110000000000
19227                                                          10987654321098765432109876543210
19228                                                          x1x01110xx1xxxxx110100xxxxxxxxxx
19229                                                          sqdmull2.  */
19230                                                       return 71;
19231                                                     }
19232                                                 }
19233                                             }
19234                                           else
19235                                             {
19236                                               if (((word >> 30) & 0x1) == 0)
19237                                                 {
19238                                                   /* 33222222222211111111110000000000
19239                                                      10987654321098765432109876543210
19240                                                      x0x01110xx1xxxxx1x1100xxxxxxxxxx
19241                                                      sqdmlsl.  */
19242                                                   return 66;
19243                                                 }
19244                                               else
19245                                                 {
19246                                                   /* 33222222222211111111110000000000
19247                                                      10987654321098765432109876543210
19248                                                      x1x01110xx1xxxxx1x1100xxxxxxxxxx
19249                                                      sqdmlsl2.  */
19250                                                   return 67;
19251                                                 }
19252                                             }
19253                                         }
19254                                     }
19255                                   else
19256                                     {
19257                                       if (((word >> 12) & 0x1) == 0)
19258                                         {
19259                                           if (((word >> 13) & 0x1) == 0)
19260                                             {
19261                                               if (((word >> 14) & 0x1) == 0)
19262                                                 {
19263                                                   if (((word >> 29) & 0x1) == 0)
19264                                                     {
19265                                                       if (((word >> 31) & 0x1) == 0)
19266                                                         {
19267                                                           if (((word >> 16) & 0x1) == 0)
19268                                                             {
19269                                                               /* 33222222222211111111110000000000
19270                                                                  10987654321098765432109876543210
19271                                                                  0x001110xx1xxxx0100010xxxxxxxxxx
19272                                                                  cmgt.  */
19273                                                               return 170;
19274                                                             }
19275                                                           else
19276                                                             {
19277                                                               if (((word >> 19) & 0x1) == 0)
19278                                                                 {
19279                                                                   if (((word >> 23) & 0x1) == 0)
19280                                                                     {
19281                                                                       /* 33222222222211111111110000000000
19282                                                                          10987654321098765432109876543210
19283                                                                          0x0011100x1x0xx1100010xxxxxxxxxx
19284                                                                          frintn.  */
19285                                                                       return 182;
19286                                                                     }
19287                                                                   else
19288                                                                     {
19289                                                                       /* 33222222222211111111110000000000
19290                                                                          10987654321098765432109876543210
19291                                                                          0x0011101x1x0xx1100010xxxxxxxxxx
19292                                                                          frintp.  */
19293                                                                       return 202;
19294                                                                     }
19295                                                                 }
19296                                                               else
19297                                                                 {
19298                                                                   if (((word >> 23) & 0x1) == 0)
19299                                                                     {
19300                                                                       /* 33222222222211111111110000000000
19301                                                                          10987654321098765432109876543210
19302                                                                          0x0011100x1x1xx1100010xxxxxxxxxx
19303                                                                          frintn.  */
19304                                                                       return 183;
19305                                                                     }
19306                                                                   else
19307                                                                     {
19308                                                                       /* 33222222222211111111110000000000
19309                                                                          10987654321098765432109876543210
19310                                                                          0x0011101x1x1xx1100010xxxxxxxxxx
19311                                                                          frintp.  */
19312                                                                       return 203;
19313                                                                     }
19314                                                                 }
19315                                                             }
19316                                                         }
19317                                                       else
19318                                                         {
19319                                                           /* 33222222222211111111110000000000
19320                                                              10987654321098765432109876543210
19321                                                              1x001110xx1xxxxx100010xxxxxxxxxx
19322                                                              sha512su1.  */
19323                                                           return 2418;
19324                                                         }
19325                                                     }
19326                                                   else
19327                                                     {
19328                                                       if (((word >> 16) & 0x1) == 0)
19329                                                         {
19330                                                           /* 33222222222211111111110000000000
19331                                                              10987654321098765432109876543210
19332                                                              xx101110xx1xxxx0100010xxxxxxxxxx
19333                                                              cmge.  */
19334                                                           return 219;
19335                                                         }
19336                                                       else
19337                                                         {
19338                                                           if (((word >> 19) & 0x1) == 0)
19339                                                             {
19340                                                               /* 33222222222211111111110000000000
19341                                                                  10987654321098765432109876543210
19342                                                                  xx101110xx1x0xx1100010xxxxxxxxxx
19343                                                                  frinta.  */
19344                                                               return 230;
19345                                                             }
19346                                                           else
19347                                                             {
19348                                                               /* 33222222222211111111110000000000
19349                                                                  10987654321098765432109876543210
19350                                                                  xx101110xx1x1xx1100010xxxxxxxxxx
19351                                                                  frinta.  */
19352                                                               return 231;
19353                                                             }
19354                                                         }
19355                                                     }
19356                                                 }
19357                                               else
19358                                                 {
19359                                                   if (((word >> 23) & 0x1) == 0)
19360                                                     {
19361                                                       if (((word >> 29) & 0x1) == 0)
19362                                                         {
19363                                                           if (((word >> 31) & 0x1) == 0)
19364                                                             {
19365                                                               if (((word >> 16) & 0x1) == 0)
19366                                                                 {
19367                                                                   /* 33222222222211111111110000000000
19368                                                                      10987654321098765432109876543210
19369                                                                      0x0011100x1xxxx0110010xxxxxxxxxx
19370                                                                      fmaxnmv.  */
19371                                                                   return 37;
19372                                                                 }
19373                                                               else
19374                                                                 {
19375                                                                   if (((word >> 19) & 0x1) == 0)
19376                                                                     {
19377                                                                       /* 33222222222211111111110000000000
19378                                                                          10987654321098765432109876543210
19379                                                                          0x0011100x1x0xx1110010xxxxxxxxxx
19380                                                                          fcvtas.  */
19381                                                                       return 190;
19382                                                                     }
19383                                                                   else
19384                                                                     {
19385                                                                       /* 33222222222211111111110000000000
19386                                                                          10987654321098765432109876543210
19387                                                                          0x0011100x1x1xx1110010xxxxxxxxxx
19388                                                                          fcvtas.  */
19389                                                                       return 191;
19390                                                                     }
19391                                                                 }
19392                                                             }
19393                                                           else
19394                                                             {
19395                                                               /* 33222222222211111111110000000000
19396                                                                  10987654321098765432109876543210
19397                                                                  1x0011100x1xxxxx110010xxxxxxxxxx
19398                                                                  sm4ekey.  */
19399                                                               return 2431;
19400                                                             }
19401                                                         }
19402                                                       else
19403                                                         {
19404                                                           if (((word >> 16) & 0x1) == 0)
19405                                                             {
19406                                                               /* 33222222222211111111110000000000
19407                                                                  10987654321098765432109876543210
19408                                                                  xx1011100x1xxxx0110010xxxxxxxxxx
19409                                                                  fmaxnmv.  */
19410                                                               return 36;
19411                                                             }
19412                                                           else
19413                                                             {
19414                                                               if (((word >> 19) & 0x1) == 0)
19415                                                                 {
19416                                                                   /* 33222222222211111111110000000000
19417                                                                      10987654321098765432109876543210
19418                                                                      xx1011100x1x0xx1110010xxxxxxxxxx
19419                                                                      fcvtau.  */
19420                                                                   return 238;
19421                                                                 }
19422                                                               else
19423                                                                 {
19424                                                                   /* 33222222222211111111110000000000
19425                                                                      10987654321098765432109876543210
19426                                                                      xx1011100x1x1xx1110010xxxxxxxxxx
19427                                                                      fcvtau.  */
19428                                                                   return 239;
19429                                                                 }
19430                                                             }
19431                                                         }
19432                                                     }
19433                                                   else
19434                                                     {
19435                                                       if (((word >> 16) & 0x1) == 0)
19436                                                         {
19437                                                           if (((word >> 19) & 0x1) == 0)
19438                                                             {
19439                                                               if (((word >> 20) & 0x1) == 0)
19440                                                                 {
19441                                                                   if (((word >> 29) & 0x1) == 0)
19442                                                                     {
19443                                                                       /* 33222222222211111111110000000000
19444                                                                          10987654321098765432109876543210
19445                                                                          xx0011101x100xx0110010xxxxxxxxxx
19446                                                                          fcmgt.  */
19447                                                                       return 194;
19448                                                                     }
19449                                                                   else
19450                                                                     {
19451                                                                       /* 33222222222211111111110000000000
19452                                                                          10987654321098765432109876543210
19453                                                                          xx1011101x100xx0110010xxxxxxxxxx
19454                                                                          fcmge.  */
19455                                                                       return 245;
19456                                                                     }
19457                                                                 }
19458                                                               else
19459                                                                 {
19460                                                                   if (((word >> 29) & 0x1) == 0)
19461                                                                     {
19462                                                                       /* 33222222222211111111110000000000
19463                                                                          10987654321098765432109876543210
19464                                                                          xx0011101x110xx0110010xxxxxxxxxx
19465                                                                          fminnmv.  */
19466                                                                       return 41;
19467                                                                     }
19468                                                                   else
19469                                                                     {
19470                                                                       /* 33222222222211111111110000000000
19471                                                                          10987654321098765432109876543210
19472                                                                          xx1011101x110xx0110010xxxxxxxxxx
19473                                                                          fminnmv.  */
19474                                                                       return 40;
19475                                                                     }
19476                                                                 }
19477                                                             }
19478                                                           else
19479                                                             {
19480                                                               if (((word >> 29) & 0x1) == 0)
19481                                                                 {
19482                                                                   /* 33222222222211111111110000000000
19483                                                                      10987654321098765432109876543210
19484                                                                      xx0011101x1x1xx0110010xxxxxxxxxx
19485                                                                      fcmgt.  */
19486                                                                   return 195;
19487                                                                 }
19488                                                               else
19489                                                                 {
19490                                                                   /* 33222222222211111111110000000000
19491                                                                      10987654321098765432109876543210
19492                                                                      xx1011101x1x1xx0110010xxxxxxxxxx
19493                                                                      fcmge.  */
19494                                                                   return 246;
19495                                                                 }
19496                                                             }
19497                                                         }
19498                                                       else
19499                                                         {
19500                                                           if (((word >> 29) & 0x1) == 0)
19501                                                             {
19502                                                               /* 33222222222211111111110000000000
19503                                                                  10987654321098765432109876543210
19504                                                                  xx0011101x1xxxx1110010xxxxxxxxxx
19505                                                                  urecpe.  */
19506                                                               return 210;
19507                                                             }
19508                                                           else
19509                                                             {
19510                                                               /* 33222222222211111111110000000000
19511                                                                  10987654321098765432109876543210
19512                                                                  xx1011101x1xxxx1110010xxxxxxxxxx
19513                                                                  ursqrte.  */
19514                                                               return 257;
19515                                                             }
19516                                                         }
19517                                                     }
19518                                                 }
19519                                             }
19520                                           else
19521                                             {
19522                                               if (((word >> 14) & 0x1) == 0)
19523                                                 {
19524                                                   if (((word >> 16) & 0x1) == 0)
19525                                                     {
19526                                                       if (((word >> 20) & 0x1) == 0)
19527                                                         {
19528                                                           /* 33222222222211111111110000000000
19529                                                              10987654321098765432109876543210
19530                                                              xxx01110xx10xxx0101010xxxxxxxxxx
19531                                                              cmlt.  */
19532                                                           return 172;
19533                                                         }
19534                                                       else
19535                                                         {
19536                                                           if (((word >> 29) & 0x1) == 0)
19537                                                             {
19538                                                               /* 33222222222211111111110000000000
19539                                                                  10987654321098765432109876543210
19540                                                                  xx001110xx11xxx0101010xxxxxxxxxx
19541                                                                  smaxv.  */
19542                                                               return 30;
19543                                                             }
19544                                                           else
19545                                                             {
19546                                                               /* 33222222222211111111110000000000
19547                                                                  10987654321098765432109876543210
19548                                                                  xx101110xx11xxx0101010xxxxxxxxxx
19549                                                                  umaxv.  */
19550                                                               return 34;
19551                                                             }
19552                                                         }
19553                                                     }
19554                                                   else
19555                                                     {
19556                                                       if (((word >> 19) & 0x1) == 0)
19557                                                         {
19558                                                           if (((word >> 20) & 0x1) == 0)
19559                                                             {
19560                                                               if (((word >> 23) & 0x1) == 0)
19561                                                                 {
19562                                                                   if (((word >> 29) & 0x1) == 0)
19563                                                                     {
19564                                                                       /* 33222222222211111111110000000000
19565                                                                          10987654321098765432109876543210
19566                                                                          xx0011100x100xx1101010xxxxxxxxxx
19567                                                                          fcvtns.  */
19568                                                                       return 186;
19569                                                                     }
19570                                                                   else
19571                                                                     {
19572                                                                       /* 33222222222211111111110000000000
19573                                                                          10987654321098765432109876543210
19574                                                                          xx1011100x100xx1101010xxxxxxxxxx
19575                                                                          fcvtnu.  */
19576                                                                       return 234;
19577                                                                     }
19578                                                                 }
19579                                                               else
19580                                                                 {
19581                                                                   if (((word >> 29) & 0x1) == 0)
19582                                                                     {
19583                                                                       /* 33222222222211111111110000000000
19584                                                                          10987654321098765432109876543210
19585                                                                          xx0011101x100xx1101010xxxxxxxxxx
19586                                                                          fcvtps.  */
19587                                                                       return 206;
19588                                                                     }
19589                                                                   else
19590                                                                     {
19591                                                                       /* 33222222222211111111110000000000
19592                                                                          10987654321098765432109876543210
19593                                                                          xx1011101x100xx1101010xxxxxxxxxx
19594                                                                          fcvtpu.  */
19595                                                                       return 253;
19596                                                                     }
19597                                                                 }
19598                                                             }
19599                                                           else
19600                                                             {
19601                                                               if (((word >> 29) & 0x1) == 0)
19602                                                                 {
19603                                                                   /* 33222222222211111111110000000000
19604                                                                      10987654321098765432109876543210
19605                                                                      xx001110xx110xx1101010xxxxxxxxxx
19606                                                                      sminv.  */
19607                                                                   return 31;
19608                                                                 }
19609                                                               else
19610                                                                 {
19611                                                                   /* 33222222222211111111110000000000
19612                                                                      10987654321098765432109876543210
19613                                                                      xx101110xx110xx1101010xxxxxxxxxx
19614                                                                      uminv.  */
19615                                                                   return 35;
19616                                                                 }
19617                                                             }
19618                                                         }
19619                                                       else
19620                                                         {
19621                                                           if (((word >> 23) & 0x1) == 0)
19622                                                             {
19623                                                               if (((word >> 29) & 0x1) == 0)
19624                                                                 {
19625                                                                   /* 33222222222211111111110000000000
19626                                                                      10987654321098765432109876543210
19627                                                                      xx0011100x1x1xx1101010xxxxxxxxxx
19628                                                                      fcvtns.  */
19629                                                                   return 187;
19630                                                                 }
19631                                                               else
19632                                                                 {
19633                                                                   /* 33222222222211111111110000000000
19634                                                                      10987654321098765432109876543210
19635                                                                      xx1011100x1x1xx1101010xxxxxxxxxx
19636                                                                      fcvtnu.  */
19637                                                                   return 235;
19638                                                                 }
19639                                                             }
19640                                                           else
19641                                                             {
19642                                                               if (((word >> 29) & 0x1) == 0)
19643                                                                 {
19644                                                                   /* 33222222222211111111110000000000
19645                                                                      10987654321098765432109876543210
19646                                                                      xx0011101x1x1xx1101010xxxxxxxxxx
19647                                                                      fcvtps.  */
19648                                                                   return 207;
19649                                                                 }
19650                                                               else
19651                                                                 {
19652                                                                   /* 33222222222211111111110000000000
19653                                                                      10987654321098765432109876543210
19654                                                                      xx1011101x1x1xx1101010xxxxxxxxxx
19655                                                                      fcvtpu.  */
19656                                                                   return 254;
19657                                                                 }
19658                                                             }
19659                                                         }
19660                                                     }
19661                                                 }
19662                                               else
19663                                                 {
19664                                                   if (((word >> 16) & 0x1) == 0)
19665                                                     {
19666                                                       if (((word >> 19) & 0x1) == 0)
19667                                                         {
19668                                                           /* 33222222222211111111110000000000
19669                                                              10987654321098765432109876543210
19670                                                              xxx01110xx1x0xx0111010xxxxxxxxxx
19671                                                              fcmlt.  */
19672                                                           return 198;
19673                                                         }
19674                                                       else
19675                                                         {
19676                                                           /* 33222222222211111111110000000000
19677                                                              10987654321098765432109876543210
19678                                                              xxx01110xx1x1xx0111010xxxxxxxxxx
19679                                                              fcmlt.  */
19680                                                           return 199;
19681                                                         }
19682                                                     }
19683                                                   else
19684                                                     {
19685                                                       if (((word >> 29) & 0x1) == 0)
19686                                                         {
19687                                                           /* 33222222222211111111110000000000
19688                                                              10987654321098765432109876543210
19689                                                              xx001110xx1xxxx1111010xxxxxxxxxx
19690                                                              frint32z.  */
19691                                                           return 158;
19692                                                         }
19693                                                       else
19694                                                         {
19695                                                           /* 33222222222211111111110000000000
19696                                                              10987654321098765432109876543210
19697                                                              xx101110xx1xxxx1111010xxxxxxxxxx
19698                                                              frint32x.  */
19699                                                           return 159;
19700                                                         }
19701                                                     }
19702                                                 }
19703                                             }
19704                                         }
19705                                       else
19706                                         {
19707                                           if (((word >> 13) & 0x1) == 0)
19708                                             {
19709                                               if (((word >> 14) & 0x1) == 0)
19710                                                 {
19711                                                   if (((word >> 16) & 0x1) == 0)
19712                                                     {
19713                                                       if (((word >> 29) & 0x1) == 0)
19714                                                         {
19715                                                           /* 33222222222211111111110000000000
19716                                                              10987654321098765432109876543210
19717                                                              xx001110xx1xxxx0100110xxxxxxxxxx
19718                                                              cmeq.  */
19719                                                           return 171;
19720                                                         }
19721                                                       else
19722                                                         {
19723                                                           /* 33222222222211111111110000000000
19724                                                              10987654321098765432109876543210
19725                                                              xx101110xx1xxxx0100110xxxxxxxxxx
19726                                                              cmle.  */
19727                                                           return 220;
19728                                                         }
19729                                                     }
19730                                                   else
19731                                                     {
19732                                                       if (((word >> 19) & 0x1) == 0)
19733                                                         {
19734                                                           if (((word >> 23) & 0x1) == 0)
19735                                                             {
19736                                                               if (((word >> 29) & 0x1) == 0)
19737                                                                 {
19738                                                                   /* 33222222222211111111110000000000
19739                                                                      10987654321098765432109876543210
19740                                                                      xx0011100x1x0xx1100110xxxxxxxxxx
19741                                                                      frintm.  */
19742                                                                   return 184;
19743                                                                 }
19744                                                               else
19745                                                                 {
19746                                                                   /* 33222222222211111111110000000000
19747                                                                      10987654321098765432109876543210
19748                                                                      xx1011100x1x0xx1100110xxxxxxxxxx
19749                                                                      frintx.  */
19750                                                                   return 232;
19751                                                                 }
19752                                                             }
19753                                                           else
19754                                                             {
19755                                                               if (((word >> 29) & 0x1) == 0)
19756                                                                 {
19757                                                                   /* 33222222222211111111110000000000
19758                                                                      10987654321098765432109876543210
19759                                                                      xx0011101x1x0xx1100110xxxxxxxxxx
19760                                                                      frintz.  */
19761                                                                   return 204;
19762                                                                 }
19763                                                               else
19764                                                                 {
19765                                                                   /* 33222222222211111111110000000000
19766                                                                      10987654321098765432109876543210
19767                                                                      xx1011101x1x0xx1100110xxxxxxxxxx
19768                                                                      frinti.  */
19769                                                                   return 251;
19770                                                                 }
19771                                                             }
19772                                                         }
19773                                                       else
19774                                                         {
19775                                                           if (((word >> 23) & 0x1) == 0)
19776                                                             {
19777                                                               if (((word >> 29) & 0x1) == 0)
19778                                                                 {
19779                                                                   /* 33222222222211111111110000000000
19780                                                                      10987654321098765432109876543210
19781                                                                      xx0011100x1x1xx1100110xxxxxxxxxx
19782                                                                      frintm.  */
19783                                                                   return 185;
19784                                                                 }
19785                                                               else
19786                                                                 {
19787                                                                   /* 33222222222211111111110000000000
19788                                                                      10987654321098765432109876543210
19789                                                                      xx1011100x1x1xx1100110xxxxxxxxxx
19790                                                                      frintx.  */
19791                                                                   return 233;
19792                                                                 }
19793                                                             }
19794                                                           else
19795                                                             {
19796                                                               if (((word >> 29) & 0x1) == 0)
19797                                                                 {
19798                                                                   /* 33222222222211111111110000000000
19799                                                                      10987654321098765432109876543210
19800                                                                      xx0011101x1x1xx1100110xxxxxxxxxx
19801                                                                      frintz.  */
19802                                                                   return 205;
19803                                                                 }
19804                                                               else
19805                                                                 {
19806                                                                   /* 33222222222211111111110000000000
19807                                                                      10987654321098765432109876543210
19808                                                                      xx1011101x1x1xx1100110xxxxxxxxxx
19809                                                                      frinti.  */
19810                                                                   return 252;
19811                                                                 }
19812                                                             }
19813                                                         }
19814                                                     }
19815                                                 }
19816                                               else
19817                                                 {
19818                                                   if (((word >> 16) & 0x1) == 0)
19819                                                     {
19820                                                       if (((word >> 19) & 0x1) == 0)
19821                                                         {
19822                                                           if (((word >> 29) & 0x1) == 0)
19823                                                             {
19824                                                               /* 33222222222211111111110000000000
19825                                                                  10987654321098765432109876543210
19826                                                                  xx001110xx1x0xx0110110xxxxxxxxxx
19827                                                                  fcmeq.  */
19828                                                               return 196;
19829                                                             }
19830                                                           else
19831                                                             {
19832                                                               /* 33222222222211111111110000000000
19833                                                                  10987654321098765432109876543210
19834                                                                  xx101110xx1x0xx0110110xxxxxxxxxx
19835                                                                  fcmle.  */
19836                                                               return 247;
19837                                                             }
19838                                                         }
19839                                                       else
19840                                                         {
19841                                                           if (((word >> 29) & 0x1) == 0)
19842                                                             {
19843                                                               /* 33222222222211111111110000000000
19844                                                                  10987654321098765432109876543210
19845                                                                  xx001110xx1x1xx0110110xxxxxxxxxx
19846                                                                  fcmeq.  */
19847                                                               return 197;
19848                                                             }
19849                                                           else
19850                                                             {
19851                                                               /* 33222222222211111111110000000000
19852                                                                  10987654321098765432109876543210
19853                                                                  xx101110xx1x1xx0110110xxxxxxxxxx
19854                                                                  fcmle.  */
19855                                                               return 248;
19856                                                             }
19857                                                         }
19858                                                     }
19859                                                   else
19860                                                     {
19861                                                       if (((word >> 19) & 0x1) == 0)
19862                                                         {
19863                                                           if (((word >> 23) & 0x1) == 0)
19864                                                             {
19865                                                               if (((word >> 29) & 0x1) == 0)
19866                                                                 {
19867                                                                   /* 33222222222211111111110000000000
19868                                                                      10987654321098765432109876543210
19869                                                                      xx0011100x1x0xx1110110xxxxxxxxxx
19870                                                                      scvtf.  */
19871                                                                   return 192;
19872                                                                 }
19873                                                               else
19874                                                                 {
19875                                                                   /* 33222222222211111111110000000000
19876                                                                      10987654321098765432109876543210
19877                                                                      xx1011100x1x0xx1110110xxxxxxxxxx
19878                                                                      ucvtf.  */
19879                                                                   return 240;
19880                                                                 }
19881                                                             }
19882                                                           else
19883                                                             {
19884                                                               if (((word >> 29) & 0x1) == 0)
19885                                                                 {
19886                                                                   /* 33222222222211111111110000000000
19887                                                                      10987654321098765432109876543210
19888                                                                      xx0011101x1x0xx1110110xxxxxxxxxx
19889                                                                      frecpe.  */
19890                                                                   return 211;
19891                                                                 }
19892                                                               else
19893                                                                 {
19894                                                                   /* 33222222222211111111110000000000
19895                                                                      10987654321098765432109876543210
19896                                                                      xx1011101x1x0xx1110110xxxxxxxxxx
19897                                                                      frsqrte.  */
19898                                                                   return 258;
19899                                                                 }
19900                                                             }
19901                                                         }
19902                                                       else
19903                                                         {
19904                                                           if (((word >> 23) & 0x1) == 0)
19905                                                             {
19906                                                               if (((word >> 29) & 0x1) == 0)
19907                                                                 {
19908                                                                   /* 33222222222211111111110000000000
19909                                                                      10987654321098765432109876543210
19910                                                                      xx0011100x1x1xx1110110xxxxxxxxxx
19911                                                                      scvtf.  */
19912                                                                   return 193;
19913                                                                 }
19914                                                               else
19915                                                                 {
19916                                                                   /* 33222222222211111111110000000000
19917                                                                      10987654321098765432109876543210
19918                                                                      xx1011100x1x1xx1110110xxxxxxxxxx
19919                                                                      ucvtf.  */
19920                                                                   return 241;
19921                                                                 }
19922                                                             }
19923                                                           else
19924                                                             {
19925                                                               if (((word >> 29) & 0x1) == 0)
19926                                                                 {
19927                                                                   /* 33222222222211111111110000000000
19928                                                                      10987654321098765432109876543210
19929                                                                      xx0011101x1x1xx1110110xxxxxxxxxx
19930                                                                      frecpe.  */
19931                                                                   return 212;
19932                                                                 }
19933                                                               else
19934                                                                 {
19935                                                                   /* 33222222222211111111110000000000
19936                                                                      10987654321098765432109876543210
19937                                                                      xx1011101x1x1xx1110110xxxxxxxxxx
19938                                                                      frsqrte.  */
19939                                                                   return 259;
19940                                                                 }
19941                                                             }
19942                                                         }
19943                                                     }
19944                                                 }
19945                                             }
19946                                           else
19947                                             {
19948                                               if (((word >> 14) & 0x1) == 0)
19949                                                 {
19950                                                   if (((word >> 16) & 0x1) == 0)
19951                                                     {
19952                                                       if (((word >> 29) & 0x1) == 0)
19953                                                         {
19954                                                           /* 33222222222211111111110000000000
19955                                                              10987654321098765432109876543210
19956                                                              xx001110xx1xxxx0101110xxxxxxxxxx
19957                                                              abs.  */
19958                                                           return 173;
19959                                                         }
19960                                                       else
19961                                                         {
19962                                                           /* 33222222222211111111110000000000
19963                                                              10987654321098765432109876543210
19964                                                              xx101110xx1xxxx0101110xxxxxxxxxx
19965                                                              neg.  */
19966                                                           return 221;
19967                                                         }
19968                                                     }
19969                                                   else
19970                                                     {
19971                                                       if (((word >> 19) & 0x1) == 0)
19972                                                         {
19973                                                           if (((word >> 20) & 0x1) == 0)
19974                                                             {
19975                                                               if (((word >> 23) & 0x1) == 0)
19976                                                                 {
19977                                                                   if (((word >> 29) & 0x1) == 0)
19978                                                                     {
19979                                                                       /* 33222222222211111111110000000000
19980                                                                          10987654321098765432109876543210
19981                                                                          xx0011100x100xx1101110xxxxxxxxxx
19982                                                                          fcvtms.  */
19983                                                                       return 188;
19984                                                                     }
19985                                                                   else
19986                                                                     {
19987                                                                       /* 33222222222211111111110000000000
19988                                                                          10987654321098765432109876543210
19989                                                                          xx1011100x100xx1101110xxxxxxxxxx
19990                                                                          fcvtmu.  */
19991                                                                       return 236;
19992                                                                     }
19993                                                                 }
19994                                                               else
19995                                                                 {
19996                                                                   if (((word >> 29) & 0x1) == 0)
19997                                                                     {
19998                                                                       /* 33222222222211111111110000000000
19999                                                                          10987654321098765432109876543210
20000                                                                          xx0011101x100xx1101110xxxxxxxxxx
20001                                                                          fcvtzs.  */
20002                                                                       return 208;
20003                                                                     }
20004                                                                   else
20005                                                                     {
20006                                                                       /* 33222222222211111111110000000000
20007                                                                          10987654321098765432109876543210
20008                                                                          xx1011101x100xx1101110xxxxxxxxxx
20009                                                                          fcvtzu.  */
20010                                                                       return 255;
20011                                                                     }
20012                                                                 }
20013                                                             }
20014                                                           else
20015                                                             {
20016                                                               /* 33222222222211111111110000000000
20017                                                                  10987654321098765432109876543210
20018                                                                  xxx01110xx110xx1101110xxxxxxxxxx
20019                                                                  addv.  */
20020                                                               return 32;
20021                                                             }
20022                                                         }
20023                                                       else
20024                                                         {
20025                                                           if (((word >> 23) & 0x1) == 0)
20026                                                             {
20027                                                               if (((word >> 29) & 0x1) == 0)
20028                                                                 {
20029                                                                   /* 33222222222211111111110000000000
20030                                                                      10987654321098765432109876543210
20031                                                                      xx0011100x1x1xx1101110xxxxxxxxxx
20032                                                                      fcvtms.  */
20033                                                                   return 189;
20034                                                                 }
20035                                                               else
20036                                                                 {
20037                                                                   /* 33222222222211111111110000000000
20038                                                                      10987654321098765432109876543210
20039                                                                      xx1011100x1x1xx1101110xxxxxxxxxx
20040                                                                      fcvtmu.  */
20041                                                                   return 237;
20042                                                                 }
20043                                                             }
20044                                                           else
20045                                                             {
20046                                                               if (((word >> 29) & 0x1) == 0)
20047                                                                 {
20048                                                                   /* 33222222222211111111110000000000
20049                                                                      10987654321098765432109876543210
20050                                                                      xx0011101x1x1xx1101110xxxxxxxxxx
20051                                                                      fcvtzs.  */
20052                                                                   return 209;
20053                                                                 }
20054                                                               else
20055                                                                 {
20056                                                                   /* 33222222222211111111110000000000
20057                                                                      10987654321098765432109876543210
20058                                                                      xx1011101x1x1xx1101110xxxxxxxxxx
20059                                                                      fcvtzu.  */
20060                                                                   return 256;
20061                                                                 }
20062                                                             }
20063                                                         }
20064                                                     }
20065                                                 }
20066                                               else
20067                                                 {
20068                                                   if (((word >> 16) & 0x1) == 0)
20069                                                     {
20070                                                       if (((word >> 19) & 0x1) == 0)
20071                                                         {
20072                                                           if (((word >> 20) & 0x1) == 0)
20073                                                             {
20074                                                               if (((word >> 29) & 0x1) == 0)
20075                                                                 {
20076                                                                   /* 33222222222211111111110000000000
20077                                                                      10987654321098765432109876543210
20078                                                                      xx001110xx100xx0111110xxxxxxxxxx
20079                                                                      fabs.  */
20080                                                                   return 200;
20081                                                                 }
20082                                                               else
20083                                                                 {
20084                                                                   /* 33222222222211111111110000000000
20085                                                                      10987654321098765432109876543210
20086                                                                      xx101110xx100xx0111110xxxxxxxxxx
20087                                                                      fneg.  */
20088                                                                   return 249;
20089                                                                 }
20090                                                             }
20091                                                           else
20092                                                             {
20093                                                               if (((word >> 23) & 0x1) == 0)
20094                                                                 {
20095                                                                   if (((word >> 29) & 0x1) == 0)
20096                                                                     {
20097                                                                       /* 33222222222211111111110000000000
20098                                                                          10987654321098765432109876543210
20099                                                                          xx0011100x110xx0111110xxxxxxxxxx
20100                                                                          fmaxv.  */
20101                                                                       return 39;
20102                                                                     }
20103                                                                   else
20104                                                                     {
20105                                                                       /* 33222222222211111111110000000000
20106                                                                          10987654321098765432109876543210
20107                                                                          xx1011100x110xx0111110xxxxxxxxxx
20108                                                                          fmaxv.  */
20109                                                                       return 38;
20110                                                                     }
20111                                                                 }
20112                                                               else
20113                                                                 {
20114                                                                   if (((word >> 29) & 0x1) == 0)
20115                                                                     {
20116                                                                       /* 33222222222211111111110000000000
20117                                                                          10987654321098765432109876543210
20118                                                                          xx0011101x110xx0111110xxxxxxxxxx
20119                                                                          fminv.  */
20120                                                                       return 43;
20121                                                                     }
20122                                                                   else
20123                                                                     {
20124                                                                       /* 33222222222211111111110000000000
20125                                                                          10987654321098765432109876543210
20126                                                                          xx1011101x110xx0111110xxxxxxxxxx
20127                                                                          fminv.  */
20128                                                                       return 42;
20129                                                                     }
20130                                                                 }
20131                                                             }
20132                                                         }
20133                                                       else
20134                                                         {
20135                                                           if (((word >> 29) & 0x1) == 0)
20136                                                             {
20137                                                               /* 33222222222211111111110000000000
20138                                                                  10987654321098765432109876543210
20139                                                                  xx001110xx1x1xx0111110xxxxxxxxxx
20140                                                                  fabs.  */
20141                                                               return 201;
20142                                                             }
20143                                                           else
20144                                                             {
20145                                                               /* 33222222222211111111110000000000
20146                                                                  10987654321098765432109876543210
20147                                                                  xx101110xx1x1xx0111110xxxxxxxxxx
20148                                                                  fneg.  */
20149                                                               return 250;
20150                                                             }
20151                                                         }
20152                                                     }
20153                                                   else
20154                                                     {
20155                                                       if (((word >> 19) & 0x1) == 0)
20156                                                         {
20157                                                           if (((word >> 23) & 0x1) == 0)
20158                                                             {
20159                                                               if (((word >> 29) & 0x1) == 0)
20160                                                                 {
20161                                                                   /* 33222222222211111111110000000000
20162                                                                      10987654321098765432109876543210
20163                                                                      xx0011100x1x0xx1111110xxxxxxxxxx
20164                                                                      frint64z.  */
20165                                                                   return 160;
20166                                                                 }
20167                                                               else
20168                                                                 {
20169                                                                   /* 33222222222211111111110000000000
20170                                                                      10987654321098765432109876543210
20171                                                                      xx1011100x1x0xx1111110xxxxxxxxxx
20172                                                                      frint64x.  */
20173                                                                   return 161;
20174                                                                 }
20175                                                             }
20176                                                           else
20177                                                             {
20178                                                               /* 33222222222211111111110000000000
20179                                                                  10987654321098765432109876543210
20180                                                                  xxx011101x1x0xx1111110xxxxxxxxxx
20181                                                                  fsqrt.  */
20182                                                               return 260;
20183                                                             }
20184                                                         }
20185                                                       else
20186                                                         {
20187                                                           /* 33222222222211111111110000000000
20188                                                              10987654321098765432109876543210
20189                                                              xxx01110xx1x1xx1111110xxxxxxxxxx
20190                                                              fsqrt.  */
20191                                                           return 261;
20192                                                         }
20193                                                     }
20194                                                 }
20195                                             }
20196                                         }
20197                                     }
20198                                 }
20199                               else
20200                                 {
20201                                   if (((word >> 11) & 0x1) == 0)
20202                                     {
20203                                       if (((word >> 12) & 0x1) == 0)
20204                                         {
20205                                           if (((word >> 13) & 0x1) == 0)
20206                                             {
20207                                               if (((word >> 14) & 0x1) == 0)
20208                                                 {
20209                                                   if (((word >> 29) & 0x1) == 0)
20210                                                     {
20211                                                       if (((word >> 31) & 0x1) == 0)
20212                                                         {
20213                                                           /* 33222222222211111111110000000000
20214                                                              10987654321098765432109876543210
20215                                                              0x001110xx1xxxxx100001xxxxxxxxxx
20216                                                              add.  */
20217                                                           return 283;
20218                                                         }
20219                                                       else
20220                                                         {
20221                                                           /* 33222222222211111111110000000000
20222                                                              10987654321098765432109876543210
20223                                                              1x001110xx1xxxxx100001xxxxxxxxxx
20224                                                              sha512h2.  */
20225                                                           return 2416;
20226                                                         }
20227                                                     }
20228                                                   else
20229                                                     {
20230                                                       /* 33222222222211111111110000000000
20231                                                          10987654321098765432109876543210
20232                                                          xx101110xx1xxxxx100001xxxxxxxxxx
20233                                                          sub.  */
20234                                                       return 335;
20235                                                     }
20236                                                 }
20237                                               else
20238                                                 {
20239                                                   if (((word >> 23) & 0x1) == 0)
20240                                                     {
20241                                                       if (((word >> 29) & 0x1) == 0)
20242                                                         {
20243                                                           if (((word >> 31) & 0x1) == 0)
20244                                                             {
20245                                                               /* 33222222222211111111110000000000
20246                                                                  10987654321098765432109876543210
20247                                                                  0x0011100x1xxxxx110001xxxxxxxxxx
20248                                                                  fmaxnm.  */
20249                                                               return 291;
20250                                                             }
20251                                                           else
20252                                                             {
20253                                                               /* 33222222222211111111110000000000
20254                                                                  10987654321098765432109876543210
20255                                                                  1x0011100x1xxxxx110001xxxxxxxxxx
20256                                                                  sm3partw2.  */
20257                                                               return 2429;
20258                                                             }
20259                                                         }
20260                                                       else
20261                                                         {
20262                                                           /* 33222222222211111111110000000000
20263                                                              10987654321098765432109876543210
20264                                                              xx1011100x1xxxxx110001xxxxxxxxxx
20265                                                              fmaxnmp.  */
20266                                                           return 342;
20267                                                         }
20268                                                     }
20269                                                   else
20270                                                     {
20271                                                       if (((word >> 29) & 0x1) == 0)
20272                                                         {
20273                                                           /* 33222222222211111111110000000000
20274                                                              10987654321098765432109876543210
20275                                                              xx0011101x1xxxxx110001xxxxxxxxxx
20276                                                              fminnm.  */
20277                                                           return 307;
20278                                                         }
20279                                                       else
20280                                                         {
20281                                                           /* 33222222222211111111110000000000
20282                                                              10987654321098765432109876543210
20283                                                              xx1011101x1xxxxx110001xxxxxxxxxx
20284                                                              fminnmp.  */
20285                                                           return 358;
20286                                                         }
20287                                                     }
20288                                                 }
20289                                             }
20290                                           else
20291                                             {
20292                                               if (((word >> 14) & 0x1) == 0)
20293                                                 {
20294                                                   if (((word >> 29) & 0x1) == 0)
20295                                                     {
20296                                                       /* 33222222222211111111110000000000
20297                                                          10987654321098765432109876543210
20298                                                          xx001110xx1xxxxx101001xxxxxxxxxx
20299                                                          smaxp.  */
20300                                                       return 287;
20301                                                     }
20302                                                   else
20303                                                     {
20304                                                       /* 33222222222211111111110000000000
20305                                                          10987654321098765432109876543210
20306                                                          xx101110xx1xxxxx101001xxxxxxxxxx
20307                                                          umaxp.  */
20308                                                       return 339;
20309                                                     }
20310                                                 }
20311                                               else
20312                                                 {
20313                                                   if (((word >> 23) & 0x1) == 0)
20314                                                     {
20315                                                       if (((word >> 29) & 0x1) == 0)
20316                                                         {
20317                                                           /* 33222222222211111111110000000000
20318                                                              10987654321098765432109876543210
20319                                                              xx0011100x1xxxxx111001xxxxxxxxxx
20320                                                              fcmeq.  */
20321                                                           return 299;
20322                                                         }
20323                                                       else
20324                                                         {
20325                                                           /* 33222222222211111111110000000000
20326                                                              10987654321098765432109876543210
20327                                                              xx1011100x1xxxxx111001xxxxxxxxxx
20328                                                              fcmge.  */
20329                                                           return 348;
20330                                                         }
20331                                                     }
20332                                                   else
20333                                                     {
20334                                                       /* 33222222222211111111110000000000
20335                                                          10987654321098765432109876543210
20336                                                          xxx011101x1xxxxx111001xxxxxxxxxx
20337                                                          fcmgt.  */
20338                                                       return 362;
20339                                                     }
20340                                                 }
20341                                             }
20342                                         }
20343                                       else
20344                                         {
20345                                           if (((word >> 13) & 0x1) == 0)
20346                                             {
20347                                               if (((word >> 14) & 0x1) == 0)
20348                                                 {
20349                                                   if (((word >> 29) & 0x1) == 0)
20350                                                     {
20351                                                       /* 33222222222211111111110000000000
20352                                                          10987654321098765432109876543210
20353                                                          xx001110xx1xxxxx100101xxxxxxxxxx
20354                                                          mla.  */
20355                                                       return 285;
20356                                                     }
20357                                                   else
20358                                                     {
20359                                                       /* 33222222222211111111110000000000
20360                                                          10987654321098765432109876543210
20361                                                          xx101110xx1xxxxx100101xxxxxxxxxx
20362                                                          mls.  */
20363                                                       return 337;
20364                                                     }
20365                                                 }
20366                                               else
20367                                                 {
20368                                                   if (((word >> 23) & 0x1) == 0)
20369                                                     {
20370                                                       if (((word >> 29) & 0x1) == 0)
20371                                                         {
20372                                                           /* 33222222222211111111110000000000
20373                                                              10987654321098765432109876543210
20374                                                              xx0011100x1xxxxx110101xxxxxxxxxx
20375                                                              fadd.  */
20376                                                           return 295;
20377                                                         }
20378                                                       else
20379                                                         {
20380                                                           /* 33222222222211111111110000000000
20381                                                              10987654321098765432109876543210
20382                                                              xx1011100x1xxxxx110101xxxxxxxxxx
20383                                                              faddp.  */
20384                                                           return 344;
20385                                                         }
20386                                                     }
20387                                                   else
20388                                                     {
20389                                                       if (((word >> 29) & 0x1) == 0)
20390                                                         {
20391                                                           /* 33222222222211111111110000000000
20392                                                              10987654321098765432109876543210
20393                                                              xx0011101x1xxxxx110101xxxxxxxxxx
20394                                                              fsub.  */
20395                                                           return 311;
20396                                                         }
20397                                                       else
20398                                                         {
20399                                                           /* 33222222222211111111110000000000
20400                                                              10987654321098765432109876543210
20401                                                              xx1011101x1xxxxx110101xxxxxxxxxx
20402                                                              fabd.  */
20403                                                           return 360;
20404                                                         }
20405                                                     }
20406                                                 }
20407                                             }
20408                                           else
20409                                             {
20410                                               if (((word >> 14) & 0x1) == 0)
20411                                                 {
20412                                                   if (((word >> 29) & 0x1) == 0)
20413                                                     {
20414                                                       /* 33222222222211111111110000000000
20415                                                          10987654321098765432109876543210
20416                                                          xx001110xx1xxxxx101101xxxxxxxxxx
20417                                                          sqdmulh.  */
20418                                                       return 289;
20419                                                     }
20420                                                   else
20421                                                     {
20422                                                       /* 33222222222211111111110000000000
20423                                                          10987654321098765432109876543210
20424                                                          xx101110xx1xxxxx101101xxxxxxxxxx
20425                                                          sqrdmulh.  */
20426                                                       return 341;
20427                                                     }
20428                                                 }
20429                                               else
20430                                                 {
20431                                                   if (((word >> 23) & 0x1) == 0)
20432                                                     {
20433                                                       if (((word >> 29) & 0x1) == 0)
20434                                                         {
20435                                                           /* 33222222222211111111110000000000
20436                                                              10987654321098765432109876543210
20437                                                              xx0011100x1xxxxx111101xxxxxxxxxx
20438                                                              fmax.  */
20439                                                           return 301;
20440                                                         }
20441                                                       else
20442                                                         {
20443                                                           /* 33222222222211111111110000000000
20444                                                              10987654321098765432109876543210
20445                                                              xx1011100x1xxxxx111101xxxxxxxxxx
20446                                                              fmaxp.  */
20447                                                           return 352;
20448                                                         }
20449                                                     }
20450                                                   else
20451                                                     {
20452                                                       if (((word >> 29) & 0x1) == 0)
20453                                                         {
20454                                                           /* 33222222222211111111110000000000
20455                                                              10987654321098765432109876543210
20456                                                              xx0011101x1xxxxx111101xxxxxxxxxx
20457                                                              fmin.  */
20458                                                           return 313;
20459                                                         }
20460                                                       else
20461                                                         {
20462                                                           /* 33222222222211111111110000000000
20463                                                              10987654321098765432109876543210
20464                                                              xx1011101x1xxxxx111101xxxxxxxxxx
20465                                                              fminp.  */
20466                                                           return 366;
20467                                                         }
20468                                                     }
20469                                                 }
20470                                             }
20471                                         }
20472                                     }
20473                                   else
20474                                     {
20475                                       if (((word >> 12) & 0x1) == 0)
20476                                         {
20477                                           if (((word >> 13) & 0x1) == 0)
20478                                             {
20479                                               if (((word >> 14) & 0x1) == 0)
20480                                                 {
20481                                                   if (((word >> 29) & 0x1) == 0)
20482                                                     {
20483                                                       if (((word >> 31) & 0x1) == 0)
20484                                                         {
20485                                                           /* 33222222222211111111110000000000
20486                                                              10987654321098765432109876543210
20487                                                              0x001110xx1xxxxx100011xxxxxxxxxx
20488                                                              cmtst.  */
20489                                                           return 284;
20490                                                         }
20491                                                       else
20492                                                         {
20493                                                           /* 33222222222211111111110000000000
20494                                                              10987654321098765432109876543210
20495                                                              1x001110xx1xxxxx100011xxxxxxxxxx
20496                                                              rax1.  */
20497                                                           return 2420;
20498                                                         }
20499                                                     }
20500                                                   else
20501                                                     {
20502                                                       /* 33222222222211111111110000000000
20503                                                          10987654321098765432109876543210
20504                                                          xx101110xx1xxxxx100011xxxxxxxxxx
20505                                                          cmeq.  */
20506                                                       return 336;
20507                                                     }
20508                                                 }
20509                                               else
20510                                                 {
20511                                                   if (((word >> 23) & 0x1) == 0)
20512                                                     {
20513                                                       if (((word >> 29) & 0x1) == 0)
20514                                                         {
20515                                                           /* 33222222222211111111110000000000
20516                                                              10987654321098765432109876543210
20517                                                              xx0011100x1xxxxx110011xxxxxxxxxx
20518                                                              fmla.  */
20519                                                           return 293;
20520                                                         }
20521                                                       else
20522                                                         {
20523                                                           if (((word >> 30) & 0x1) == 0)
20524                                                             {
20525                                                               /* 33222222222211111111110000000000
20526                                                                  10987654321098765432109876543210
20527                                                                  x01011100x1xxxxx110011xxxxxxxxxx
20528                                                                  fmlal2.  */
20529                                                               return 2434;
20530                                                             }
20531                                                           else
20532                                                             {
20533                                                               /* 33222222222211111111110000000000
20534                                                                  10987654321098765432109876543210
20535                                                                  x11011100x1xxxxx110011xxxxxxxxxx
20536                                                                  fmlal2.  */
20537                                                               return 2438;
20538                                                             }
20539                                                         }
20540                                                     }
20541                                                   else
20542                                                     {
20543                                                       if (((word >> 29) & 0x1) == 0)
20544                                                         {
20545                                                           /* 33222222222211111111110000000000
20546                                                              10987654321098765432109876543210
20547                                                              xx0011101x1xxxxx110011xxxxxxxxxx
20548                                                              fmls.  */
20549                                                           return 309;
20550                                                         }
20551                                                       else
20552                                                         {
20553                                                           if (((word >> 30) & 0x1) == 0)
20554                                                             {
20555                                                               /* 33222222222211111111110000000000
20556                                                                  10987654321098765432109876543210
20557                                                                  x01011101x1xxxxx110011xxxxxxxxxx
20558                                                                  fmlsl2.  */
20559                                                               return 2435;
20560                                                             }
20561                                                           else
20562                                                             {
20563                                                               /* 33222222222211111111110000000000
20564                                                                  10987654321098765432109876543210
20565                                                                  x11011101x1xxxxx110011xxxxxxxxxx
20566                                                                  fmlsl2.  */
20567                                                               return 2439;
20568                                                             }
20569                                                         }
20570                                                     }
20571                                                 }
20572                                             }
20573                                           else
20574                                             {
20575                                               if (((word >> 14) & 0x1) == 0)
20576                                                 {
20577                                                   if (((word >> 29) & 0x1) == 0)
20578                                                     {
20579                                                       /* 33222222222211111111110000000000
20580                                                          10987654321098765432109876543210
20581                                                          xx001110xx1xxxxx101011xxxxxxxxxx
20582                                                          sminp.  */
20583                                                       return 288;
20584                                                     }
20585                                                   else
20586                                                     {
20587                                                       /* 33222222222211111111110000000000
20588                                                          10987654321098765432109876543210
20589                                                          xx101110xx1xxxxx101011xxxxxxxxxx
20590                                                          uminp.  */
20591                                                       return 340;
20592                                                     }
20593                                                 }
20594                                               else
20595                                                 {
20596                                                   if (((word >> 23) & 0x1) == 0)
20597                                                     {
20598                                                       if (((word >> 29) & 0x1) == 0)
20599                                                         {
20600                                                           if (((word >> 30) & 0x1) == 0)
20601                                                             {
20602                                                               /* 33222222222211111111110000000000
20603                                                                  10987654321098765432109876543210
20604                                                                  x00011100x1xxxxx111011xxxxxxxxxx
20605                                                                  fmlal.  */
20606                                                               return 2432;
20607                                                             }
20608                                                           else
20609                                                             {
20610                                                               /* 33222222222211111111110000000000
20611                                                                  10987654321098765432109876543210
20612                                                                  x10011100x1xxxxx111011xxxxxxxxxx
20613                                                                  fmlal.  */
20614                                                               return 2436;
20615                                                             }
20616                                                         }
20617                                                       else
20618                                                         {
20619                                                           /* 33222222222211111111110000000000
20620                                                              10987654321098765432109876543210
20621                                                              xx1011100x1xxxxx111011xxxxxxxxxx
20622                                                              facge.  */
20623                                                           return 350;
20624                                                         }
20625                                                     }
20626                                                   else
20627                                                     {
20628                                                       if (((word >> 29) & 0x1) == 0)
20629                                                         {
20630                                                           if (((word >> 30) & 0x1) == 0)
20631                                                             {
20632                                                               /* 33222222222211111111110000000000
20633                                                                  10987654321098765432109876543210
20634                                                                  x00011101x1xxxxx111011xxxxxxxxxx
20635                                                                  fmlsl.  */
20636                                                               return 2433;
20637                                                             }
20638                                                           else
20639                                                             {
20640                                                               /* 33222222222211111111110000000000
20641                                                                  10987654321098765432109876543210
20642                                                                  x10011101x1xxxxx111011xxxxxxxxxx
20643                                                                  fmlsl.  */
20644                                                               return 2437;
20645                                                             }
20646                                                         }
20647                                                       else
20648                                                         {
20649                                                           /* 33222222222211111111110000000000
20650                                                              10987654321098765432109876543210
20651                                                              xx1011101x1xxxxx111011xxxxxxxxxx
20652                                                              facgt.  */
20653                                                           return 364;
20654                                                         }
20655                                                     }
20656                                                 }
20657                                             }
20658                                         }
20659                                       else
20660                                         {
20661                                           if (((word >> 13) & 0x1) == 0)
20662                                             {
20663                                               if (((word >> 14) & 0x1) == 0)
20664                                                 {
20665                                                   if (((word >> 29) & 0x1) == 0)
20666                                                     {
20667                                                       /* 33222222222211111111110000000000
20668                                                          10987654321098765432109876543210
20669                                                          xx001110xx1xxxxx100111xxxxxxxxxx
20670                                                          mul.  */
20671                                                       return 286;
20672                                                     }
20673                                                   else
20674                                                     {
20675                                                       /* 33222222222211111111110000000000
20676                                                          10987654321098765432109876543210
20677                                                          xx101110xx1xxxxx100111xxxxxxxxxx
20678                                                          pmul.  */
20679                                                       return 338;
20680                                                     }
20681                                                 }
20682                                               else
20683                                                 {
20684                                                   if (((word >> 29) & 0x1) == 0)
20685                                                     {
20686                                                       /* 33222222222211111111110000000000
20687                                                          10987654321098765432109876543210
20688                                                          xx001110xx1xxxxx110111xxxxxxxxxx
20689                                                          fmulx.  */
20690                                                       return 297;
20691                                                     }
20692                                                   else
20693                                                     {
20694                                                       /* 33222222222211111111110000000000
20695                                                          10987654321098765432109876543210
20696                                                          xx101110xx1xxxxx110111xxxxxxxxxx
20697                                                          fmul.  */
20698                                                       return 346;
20699                                                     }
20700                                                 }
20701                                             }
20702                                           else
20703                                             {
20704                                               if (((word >> 14) & 0x1) == 0)
20705                                                 {
20706                                                   /* 33222222222211111111110000000000
20707                                                      10987654321098765432109876543210
20708                                                      xxx01110xx1xxxxx101111xxxxxxxxxx
20709                                                      addp.  */
20710                                                   return 290;
20711                                                 }
20712                                               else
20713                                                 {
20714                                                   if (((word >> 23) & 0x1) == 0)
20715                                                     {
20716                                                       if (((word >> 29) & 0x1) == 0)
20717                                                         {
20718                                                           /* 33222222222211111111110000000000
20719                                                              10987654321098765432109876543210
20720                                                              xx0011100x1xxxxx111111xxxxxxxxxx
20721                                                              frecps.  */
20722                                                           return 303;
20723                                                         }
20724                                                       else
20725                                                         {
20726                                                           /* 33222222222211111111110000000000
20727                                                              10987654321098765432109876543210
20728                                                              xx1011100x1xxxxx111111xxxxxxxxxx
20729                                                              fdiv.  */
20730                                                           return 354;
20731                                                         }
20732                                                     }
20733                                                   else
20734                                                     {
20735                                                       /* 33222222222211111111110000000000
20736                                                          10987654321098765432109876543210
20737                                                          xxx011101x1xxxxx111111xxxxxxxxxx
20738                                                          frsqrts.  */
20739                                                       return 315;
20740                                                     }
20741                                                 }
20742                                             }
20743                                         }
20744                                     }
20745                                 }
20746                             }
20747                         }
20748                       else
20749                         {
20750                           if (((word >> 10) & 0x1) == 0)
20751                             {
20752                               if (((word >> 11) & 0x1) == 0)
20753                                 {
20754                                   if (((word >> 12) & 0x1) == 0)
20755                                     {
20756                                       if (((word >> 13) & 0x1) == 0)
20757                                         {
20758                                           if (((word >> 14) & 0x1) == 0)
20759                                             {
20760                                               if (((word >> 16) & 0x1) == 0)
20761                                                 {
20762                                                   if (((word >> 17) & 0x1) == 0)
20763                                                     {
20764                                                       if (((word >> 18) & 0x1) == 0)
20765                                                         {
20766                                                           if (((word >> 19) & 0x1) == 0)
20767                                                             {
20768                                                               if (((word >> 20) & 0x1) == 0)
20769                                                                 {
20770                                                                   /* 33222222222211111111110000000000
20771                                                                      10987654321098765432109876543210
20772                                                                      xxx11110xx100000x00000xxxxxxxxxx
20773                                                                      fcvtns.  */
20774                                                                   return 768;
20775                                                                 }
20776                                                               else
20777                                                                 {
20778                                                                   /* 33222222222211111111110000000000
20779                                                                      10987654321098765432109876543210
20780                                                                      xxx11110xx110000x00000xxxxxxxxxx
20781                                                                      fcvtms.  */
20782                                                                   return 788;
20783                                                                 }
20784                                                             }
20785                                                           else
20786                                                             {
20787                                                               if (((word >> 20) & 0x1) == 0)
20788                                                                 {
20789                                                                   /* 33222222222211111111110000000000
20790                                                                      10987654321098765432109876543210
20791                                                                      xxx11110xx101000x00000xxxxxxxxxx
20792                                                                      fcvtps.  */
20793                                                                   return 784;
20794                                                                 }
20795                                                               else
20796                                                                 {
20797                                                                   /* 33222222222211111111110000000000
20798                                                                      10987654321098765432109876543210
20799                                                                      xxx11110xx111000x00000xxxxxxxxxx
20800                                                                      fcvtzs.  */
20801                                                                   return 792;
20802                                                                 }
20803                                                             }
20804                                                         }
20805                                                       else
20806                                                         {
20807                                                           /* 33222222222211111111110000000000
20808                                                              10987654321098765432109876543210
20809                                                              xxx11110xx1xx100x00000xxxxxxxxxx
20810                                                              fcvtas.  */
20811                                                           return 776;
20812                                                         }
20813                                                     }
20814                                                   else
20815                                                     {
20816                                                       if (((word >> 18) & 0x1) == 0)
20817                                                         {
20818                                                           /* 33222222222211111111110000000000
20819                                                              10987654321098765432109876543210
20820                                                              xxx11110xx1xx010x00000xxxxxxxxxx
20821                                                              scvtf.  */
20822                                                           return 772;
20823                                                         }
20824                                                       else
20825                                                         {
20826                                                           if (((word >> 19) & 0x1) == 0)
20827                                                             {
20828                                                               /* 33222222222211111111110000000000
20829                                                                  10987654321098765432109876543210
20830                                                                  xxx11110xx1x0110x00000xxxxxxxxxx
20831                                                                  fmov.  */
20832                                                               return 780;
20833                                                             }
20834                                                           else
20835                                                             {
20836                                                               if (((word >> 20) & 0x1) == 0)
20837                                                                 {
20838                                                                   /* 33222222222211111111110000000000
20839                                                                      10987654321098765432109876543210
20840                                                                      xxx11110xx101110x00000xxxxxxxxxx
20841                                                                      fmov.  */
20842                                                                   return 796;
20843                                                                 }
20844                                                               else
20845                                                                 {
20846                                                                   /* 33222222222211111111110000000000
20847                                                                      10987654321098765432109876543210
20848                                                                      xxx11110xx111110x00000xxxxxxxxxx
20849                                                                      fjcvtzs.  */
20850                                                                   return 798;
20851                                                                 }
20852                                                             }
20853                                                         }
20854                                                     }
20855                                                 }
20856                                               else
20857                                                 {
20858                                                   if (((word >> 17) & 0x1) == 0)
20859                                                     {
20860                                                       if (((word >> 18) & 0x1) == 0)
20861                                                         {
20862                                                           if (((word >> 19) & 0x1) == 0)
20863                                                             {
20864                                                               if (((word >> 20) & 0x1) == 0)
20865                                                                 {
20866                                                                   /* 33222222222211111111110000000000
20867                                                                      10987654321098765432109876543210
20868                                                                      xxx11110xx100001x00000xxxxxxxxxx
20869                                                                      fcvtnu.  */
20870                                                                   return 770;
20871                                                                 }
20872                                                               else
20873                                                                 {
20874                                                                   /* 33222222222211111111110000000000
20875                                                                      10987654321098765432109876543210
20876                                                                      xxx11110xx110001x00000xxxxxxxxxx
20877                                                                      fcvtmu.  */
20878                                                                   return 790;
20879                                                                 }
20880                                                             }
20881                                                           else
20882                                                             {
20883                                                               if (((word >> 20) & 0x1) == 0)
20884                                                                 {
20885                                                                   /* 33222222222211111111110000000000
20886                                                                      10987654321098765432109876543210
20887                                                                      xxx11110xx101001x00000xxxxxxxxxx
20888                                                                      fcvtpu.  */
20889                                                                   return 786;
20890                                                                 }
20891                                                               else
20892                                                                 {
20893                                                                   /* 33222222222211111111110000000000
20894                                                                      10987654321098765432109876543210
20895                                                                      xxx11110xx111001x00000xxxxxxxxxx
20896                                                                      fcvtzu.  */
20897                                                                   return 794;
20898                                                                 }
20899                                                             }
20900                                                         }
20901                                                       else
20902                                                         {
20903                                                           /* 33222222222211111111110000000000
20904                                                              10987654321098765432109876543210
20905                                                              xxx11110xx1xx101x00000xxxxxxxxxx
20906                                                              fcvtau.  */
20907                                                           return 778;
20908                                                         }
20909                                                     }
20910                                                   else
20911                                                     {
20912                                                       if (((word >> 18) & 0x1) == 0)
20913                                                         {
20914                                                           /* 33222222222211111111110000000000
20915                                                              10987654321098765432109876543210
20916                                                              xxx11110xx1xx011x00000xxxxxxxxxx
20917                                                              ucvtf.  */
20918                                                           return 774;
20919                                                         }
20920                                                       else
20921                                                         {
20922                                                           if (((word >> 19) & 0x1) == 0)
20923                                                             {
20924                                                               /* 33222222222211111111110000000000
20925                                                                  10987654321098765432109876543210
20926                                                                  xxx11110xx1x0111x00000xxxxxxxxxx
20927                                                                  fmov.  */
20928                                                               return 782;
20929                                                             }
20930                                                           else
20931                                                             {
20932                                                               /* 33222222222211111111110000000000
20933                                                                  10987654321098765432109876543210
20934                                                                  xxx11110xx1x1111x00000xxxxxxxxxx
20935                                                                  fmov.  */
20936                                                               return 797;
20937                                                             }
20938                                                         }
20939                                                     }
20940                                                 }
20941                                             }
20942                                           else
20943                                             {
20944                                               if (((word >> 17) & 0x1) == 0)
20945                                                 {
20946                                                   if (((word >> 15) & 0x1) == 0)
20947                                                     {
20948                                                       if (((word >> 16) & 0x1) == 0)
20949                                                         {
20950                                                           if (((word >> 18) & 0x1) == 0)
20951                                                             {
20952                                                               if (((word >> 19) & 0x1) == 0)
20953                                                                 {
20954                                                                   /* 33222222222211111111110000000000
20955                                                                      10987654321098765432109876543210
20956                                                                      xxx11110xx1x0000010000xxxxxxxxxx
20957                                                                      fmov.  */
20958                                                                   return 817;
20959                                                                 }
20960                                                               else
20961                                                                 {
20962                                                                   /* 33222222222211111111110000000000
20963                                                                      10987654321098765432109876543210
20964                                                                      xxx11110xx1x1000010000xxxxxxxxxx
20965                                                                      frint32z.  */
20966                                                                   return 813;
20967                                                                 }
20968                                                             }
20969                                                           else
20970                                                             {
20971                                                               /* 33222222222211111111110000000000
20972                                                                  10987654321098765432109876543210
20973                                                                  xxx11110xx1xx100010000xxxxxxxxxx
20974                                                                  frintn.  */
20975                                                               return 826;
20976                                                             }
20977                                                         }
20978                                                       else
20979                                                         {
20980                                                           if (((word >> 18) & 0x1) == 0)
20981                                                             {
20982                                                               if (((word >> 19) & 0x1) == 0)
20983                                                                 {
20984                                                                   /* 33222222222211111111110000000000
20985                                                                      10987654321098765432109876543210
20986                                                                      xxx11110xx1x0001010000xxxxxxxxxx
20987                                                                      fneg.  */
20988                                                                   return 821;
20989                                                                 }
20990                                                               else
20991                                                                 {
20992                                                                   /* 33222222222211111111110000000000
20993                                                                      10987654321098765432109876543210
20994                                                                      xxx11110xx1x1001010000xxxxxxxxxx
20995                                                                      frint64z.  */
20996                                                                   return 815;
20997                                                                 }
20998                                                             }
20999                                                           else
21000                                                             {
21001                                                               /* 33222222222211111111110000000000
21002                                                                  10987654321098765432109876543210
21003                                                                  xxx11110xx1xx101010000xxxxxxxxxx
21004                                                                  frintm.  */
21005                                                               return 830;
21006                                                             }
21007                                                         }
21008                                                     }
21009                                                   else
21010                                                     {
21011                                                       if (((word >> 16) & 0x1) == 0)
21012                                                         {
21013                                                           if (((word >> 18) & 0x1) == 0)
21014                                                             {
21015                                                               if (((word >> 19) & 0x1) == 0)
21016                                                                 {
21017                                                                   /* 33222222222211111111110000000000
21018                                                                      10987654321098765432109876543210
21019                                                                      xxx11110xx1x0000110000xxxxxxxxxx
21020                                                                      fabs.  */
21021                                                                   return 819;
21022                                                                 }
21023                                                               else
21024                                                                 {
21025                                                                   /* 33222222222211111111110000000000
21026                                                                      10987654321098765432109876543210
21027                                                                      xxx11110xx1x1000110000xxxxxxxxxx
21028                                                                      frint32x.  */
21029                                                                   return 814;
21030                                                                 }
21031                                                             }
21032                                                           else
21033                                                             {
21034                                                               /* 33222222222211111111110000000000
21035                                                                  10987654321098765432109876543210
21036                                                                  xxx11110xx1xx100110000xxxxxxxxxx
21037                                                                  frintp.  */
21038                                                               return 828;
21039                                                             }
21040                                                         }
21041                                                       else
21042                                                         {
21043                                                           if (((word >> 18) & 0x1) == 0)
21044                                                             {
21045                                                               if (((word >> 19) & 0x1) == 0)
21046                                                                 {
21047                                                                   /* 33222222222211111111110000000000
21048                                                                      10987654321098765432109876543210
21049                                                                      xxx11110xx1x0001110000xxxxxxxxxx
21050                                                                      fsqrt.  */
21051                                                                   return 823;
21052                                                                 }
21053                                                               else
21054                                                                 {
21055                                                                   /* 33222222222211111111110000000000
21056                                                                      10987654321098765432109876543210
21057                                                                      xxx11110xx1x1001110000xxxxxxxxxx
21058                                                                      frint64x.  */
21059                                                                   return 816;
21060                                                                 }
21061                                                             }
21062                                                           else
21063                                                             {
21064                                                               /* 33222222222211111111110000000000
21065                                                                  10987654321098765432109876543210
21066                                                                  xxx11110xx1xx101110000xxxxxxxxxx
21067                                                                  frintz.  */
21068                                                               return 832;
21069                                                             }
21070                                                         }
21071                                                     }
21072                                                 }
21073                                               else
21074                                                 {
21075                                                   if (((word >> 18) & 0x1) == 0)
21076                                                     {
21077                                                       /* 33222222222211111111110000000000
21078                                                          10987654321098765432109876543210
21079                                                          xxx11110xx1xx01xx10000xxxxxxxxxx
21080                                                          fcvt.  */
21081                                                       return 825;
21082                                                     }
21083                                                   else
21084                                                     {
21085                                                       if (((word >> 15) & 0x1) == 0)
21086                                                         {
21087                                                           if (((word >> 16) & 0x1) == 0)
21088                                                             {
21089                                                               /* 33222222222211111111110000000000
21090                                                                  10987654321098765432109876543210
21091                                                                  xxx11110xx1xx110010000xxxxxxxxxx
21092                                                                  frinta.  */
21093                                                               return 834;
21094                                                             }
21095                                                           else
21096                                                             {
21097                                                               /* 33222222222211111111110000000000
21098                                                                  10987654321098765432109876543210
21099                                                                  xxx11110xx1xx111010000xxxxxxxxxx
21100                                                                  frintx.  */
21101                                                               return 836;
21102                                                             }
21103                                                         }
21104                                                       else
21105                                                         {
21106                                                           /* 33222222222211111111110000000000
21107                                                              10987654321098765432109876543210
21108                                                              xxx11110xx1xx11x110000xxxxxxxxxx
21109                                                              frinti.  */
21110                                                           return 838;
21111                                                         }
21112                                                     }
21113                                                 }
21114                                             }
21115                                         }
21116                                       else
21117                                         {
21118                                           if (((word >> 3) & 0x1) == 0)
21119                                             {
21120                                               if (((word >> 4) & 0x1) == 0)
21121                                                 {
21122                                                   /* 33222222222211111111110000000000
21123                                                      10987654321098765432109876543210
21124                                                      xxx11110xx1xxxxxxx1000xxxxx00xxx
21125                                                      fcmp.  */
21126                                                   return 803;
21127                                                 }
21128                                               else
21129                                                 {
21130                                                   /* 33222222222211111111110000000000
21131                                                      10987654321098765432109876543210
21132                                                      xxx11110xx1xxxxxxx1000xxxxx10xxx
21133                                                      fcmpe.  */
21134                                                   return 805;
21135                                                 }
21136                                             }
21137                                           else
21138                                             {
21139                                               if (((word >> 4) & 0x1) == 0)
21140                                                 {
21141                                                   /* 33222222222211111111110000000000
21142                                                      10987654321098765432109876543210
21143                                                      xxx11110xx1xxxxxxx1000xxxxx01xxx
21144                                                      fcmp.  */
21145                                                   return 807;
21146                                                 }
21147                                               else
21148                                                 {
21149                                                   /* 33222222222211111111110000000000
21150                                                      10987654321098765432109876543210
21151                                                      xxx11110xx1xxxxxxx1000xxxxx11xxx
21152                                                      fcmpe.  */
21153                                                   return 809;
21154                                                 }
21155                                             }
21156                                         }
21157                                     }
21158                                   else
21159                                     {
21160                                       if (((word >> 30) & 0x1) == 0)
21161                                         {
21162                                           /* 33222222222211111111110000000000
21163                                              10987654321098765432109876543210
21164                                              x0x11110xx1xxxxxxxx100xxxxxxxxxx
21165                                              fmov.  */
21166                                           return 866;
21167                                         }
21168                                       else
21169                                         {
21170                                           if (((word >> 13) & 0x1) == 0)
21171                                             {
21172                                               if (((word >> 14) & 0x1) == 0)
21173                                                 {
21174                                                   /* 33222222222211111111110000000000
21175                                                      10987654321098765432109876543210
21176                                                      x1x11110xx1xxxxxx00100xxxxxxxxxx
21177                                                      sqdmlal.  */
21178                                                   return 422;
21179                                                 }
21180                                               else
21181                                                 {
21182                                                   /* 33222222222211111111110000000000
21183                                                      10987654321098765432109876543210
21184                                                      x1x11110xx1xxxxxx10100xxxxxxxxxx
21185                                                      sqdmull.  */
21186                                                   return 424;
21187                                                 }
21188                                             }
21189                                           else
21190                                             {
21191                                               /* 33222222222211111111110000000000
21192                                                  10987654321098765432109876543210
21193                                                  x1x11110xx1xxxxxxx1100xxxxxxxxxx
21194                                                  sqdmlsl.  */
21195                                               return 423;
21196                                             }
21197                                         }
21198                                     }
21199                                 }
21200                               else
21201                                 {
21202                                   if (((word >> 12) & 0x1) == 0)
21203                                     {
21204                                       if (((word >> 13) & 0x1) == 0)
21205                                         {
21206                                           if (((word >> 14) & 0x1) == 0)
21207                                             {
21208                                               if (((word >> 15) & 0x1) == 0)
21209                                                 {
21210                                                   if (((word >> 30) & 0x1) == 0)
21211                                                     {
21212                                                       /* 33222222222211111111110000000000
21213                                                          10987654321098765432109876543210
21214                                                          x0x11110xx1xxxxx000010xxxxxxxxxx
21215                                                          fmul.  */
21216                                                       return 840;
21217                                                     }
21218                                                   else
21219                                                     {
21220                                                       /* 33222222222211111111110000000000
21221                                                          10987654321098765432109876543210
21222                                                          x1x11110xx1xxxxx000010xxxxxxxxxx
21223                                                          sha1h.  */
21224                                                       return 675;
21225                                                     }
21226                                                 }
21227                                               else
21228                                                 {
21229                                                   if (((word >> 29) & 0x1) == 0)
21230                                                     {
21231                                                       if (((word >> 30) & 0x1) == 0)
21232                                                         {
21233                                                           /* 33222222222211111111110000000000
21234                                                              10987654321098765432109876543210
21235                                                              x0011110xx1xxxxx100010xxxxxxxxxx
21236                                                              fnmul.  */
21237                                                           return 856;
21238                                                         }
21239                                                       else
21240                                                         {
21241                                                           /* 33222222222211111111110000000000
21242                                                              10987654321098765432109876543210
21243                                                              x1011110xx1xxxxx100010xxxxxxxxxx
21244                                                              cmgt.  */
21245                                                           return 482;
21246                                                         }
21247                                                     }
21248                                                   else
21249                                                     {
21250                                                       /* 33222222222211111111110000000000
21251                                                          10987654321098765432109876543210
21252                                                          xx111110xx1xxxxx100010xxxxxxxxxx
21253                                                          cmge.  */
21254                                                       return 511;
21255                                                     }
21256                                                 }
21257                                             }
21258                                           else
21259                                             {
21260                                               if (((word >> 15) & 0x1) == 0)
21261                                                 {
21262                                                   if (((word >> 29) & 0x1) == 0)
21263                                                     {
21264                                                       if (((word >> 30) & 0x1) == 0)
21265                                                         {
21266                                                           /* 33222222222211111111110000000000
21267                                                              10987654321098765432109876543210
21268                                                              x0011110xx1xxxxx010010xxxxxxxxxx
21269                                                              fmax.  */
21270                                                           return 848;
21271                                                         }
21272                                                       else
21273                                                         {
21274                                                           /* 33222222222211111111110000000000
21275                                                              10987654321098765432109876543210
21276                                                              x1011110xx1xxxxx010010xxxxxxxxxx
21277                                                              sqxtn.  */
21278                                                           return 486;
21279                                                         }
21280                                                     }
21281                                                   else
21282                                                     {
21283                                                       /* 33222222222211111111110000000000
21284                                                          10987654321098765432109876543210
21285                                                          xx111110xx1xxxxx010010xxxxxxxxxx
21286                                                          uqxtn.  */
21287                                                       return 515;
21288                                                     }
21289                                                 }
21290                                               else
21291                                                 {
21292                                                   if (((word >> 16) & 0x1) == 0)
21293                                                     {
21294                                                       if (((word >> 19) & 0x1) == 0)
21295                                                         {
21296                                                           if (((word >> 20) & 0x1) == 0)
21297                                                             {
21298                                                               if (((word >> 29) & 0x1) == 0)
21299                                                                 {
21300                                                                   /* 33222222222211111111110000000000
21301                                                                      10987654321098765432109876543210
21302                                                                      xx011110xx100xx0110010xxxxxxxxxx
21303                                                                      fcmgt.  */
21304                                                                   return 495;
21305                                                                 }
21306                                                               else
21307                                                                 {
21308                                                                   /* 33222222222211111111110000000000
21309                                                                      10987654321098765432109876543210
21310                                                                      xx111110xx100xx0110010xxxxxxxxxx
21311                                                                      fcmge.  */
21312                                                                   return 525;
21313                                                                 }
21314                                                             }
21315                                                           else
21316                                                             {
21317                                                               if (((word >> 23) & 0x1) == 0)
21318                                                                 {
21319                                                                   if (((word >> 29) & 0x1) == 0)
21320                                                                     {
21321                                                                       /* 33222222222211111111110000000000
21322                                                                          10987654321098765432109876543210
21323                                                                          xx0111100x110xx0110010xxxxxxxxxx
21324                                                                          fmaxnmp.  */
21325                                                                       return 539;
21326                                                                     }
21327                                                                   else
21328                                                                     {
21329                                                                       /* 33222222222211111111110000000000
21330                                                                          10987654321098765432109876543210
21331                                                                          xx1111100x110xx0110010xxxxxxxxxx
21332                                                                          fmaxnmp.  */
21333                                                                       return 538;
21334                                                                     }
21335                                                                 }
21336                                                               else
21337                                                                 {
21338                                                                   if (((word >> 29) & 0x1) == 0)
21339                                                                     {
21340                                                                       /* 33222222222211111111110000000000
21341                                                                          10987654321098765432109876543210
21342                                                                          xx0111101x110xx0110010xxxxxxxxxx
21343                                                                          fminnmp.  */
21344                                                                       return 545;
21345                                                                     }
21346                                                                   else
21347                                                                     {
21348                                                                       /* 33222222222211111111110000000000
21349                                                                          10987654321098765432109876543210
21350                                                                          xx1111101x110xx0110010xxxxxxxxxx
21351                                                                          fminnmp.  */
21352                                                                       return 544;
21353                                                                     }
21354                                                                 }
21355                                                             }
21356                                                         }
21357                                                       else
21358                                                         {
21359                                                           if (((word >> 29) & 0x1) == 0)
21360                                                             {
21361                                                               /* 33222222222211111111110000000000
21362                                                                  10987654321098765432109876543210
21363                                                                  xx011110xx1x1xx0110010xxxxxxxxxx
21364                                                                  fcmgt.  */
21365                                                               return 496;
21366                                                             }
21367                                                           else
21368                                                             {
21369                                                               /* 33222222222211111111110000000000
21370                                                                  10987654321098765432109876543210
21371                                                                  xx111110xx1x1xx0110010xxxxxxxxxx
21372                                                                  fcmge.  */
21373                                                               return 526;
21374                                                             }
21375                                                         }
21376                                                     }
21377                                                   else
21378                                                     {
21379                                                       if (((word >> 19) & 0x1) == 0)
21380                                                         {
21381                                                           if (((word >> 29) & 0x1) == 0)
21382                                                             {
21383                                                               /* 33222222222211111111110000000000
21384                                                                  10987654321098765432109876543210
21385                                                                  xx011110xx1x0xx1110010xxxxxxxxxx
21386                                                                  fcvtas.  */
21387                                                               return 491;
21388                                                             }
21389                                                           else
21390                                                             {
21391                                                               /* 33222222222211111111110000000000
21392                                                                  10987654321098765432109876543210
21393                                                                  xx111110xx1x0xx1110010xxxxxxxxxx
21394                                                                  fcvtau.  */
21395                                                               return 521;
21396                                                             }
21397                                                         }
21398                                                       else
21399                                                         {
21400                                                           if (((word >> 29) & 0x1) == 0)
21401                                                             {
21402                                                               /* 33222222222211111111110000000000
21403                                                                  10987654321098765432109876543210
21404                                                                  xx011110xx1x1xx1110010xxxxxxxxxx
21405                                                                  fcvtas.  */
21406                                                               return 492;
21407                                                             }
21408                                                           else
21409                                                             {
21410                                                               /* 33222222222211111111110000000000
21411                                                                  10987654321098765432109876543210
21412                                                                  xx111110xx1x1xx1110010xxxxxxxxxx
21413                                                                  fcvtau.  */
21414                                                               return 522;
21415                                                             }
21416                                                         }
21417                                                     }
21418                                                 }
21419                                             }
21420                                         }
21421                                       else
21422                                         {
21423                                           if (((word >> 14) & 0x1) == 0)
21424                                             {
21425                                               if (((word >> 15) & 0x1) == 0)
21426                                                 {
21427                                                   if (((word >> 29) & 0x1) == 0)
21428                                                     {
21429                                                       if (((word >> 30) & 0x1) == 0)
21430                                                         {
21431                                                           /* 33222222222211111111110000000000
21432                                                              10987654321098765432109876543210
21433                                                              x0011110xx1xxxxx001010xxxxxxxxxx
21434                                                              fadd.  */
21435                                                           return 844;
21436                                                         }
21437                                                       else
21438                                                         {
21439                                                           /* 33222222222211111111110000000000
21440                                                              10987654321098765432109876543210
21441                                                              x1011110xx1xxxxx001010xxxxxxxxxx
21442                                                              sha256su0.  */
21443                                                           return 677;
21444                                                         }
21445                                                     }
21446                                                   else
21447                                                     {
21448                                                       /* 33222222222211111111110000000000
21449                                                          10987654321098765432109876543210
21450                                                          xx111110xx1xxxxx001010xxxxxxxxxx
21451                                                          sqxtun.  */
21452                                                       return 514;
21453                                                     }
21454                                                 }
21455                                               else
21456                                                 {
21457                                                   if (((word >> 16) & 0x1) == 0)
21458                                                     {
21459                                                       /* 33222222222211111111110000000000
21460                                                          10987654321098765432109876543210
21461                                                          xxx11110xx1xxxx0101010xxxxxxxxxx
21462                                                          cmlt.  */
21463                                                       return 484;
21464                                                     }
21465                                                   else
21466                                                     {
21467                                                       if (((word >> 19) & 0x1) == 0)
21468                                                         {
21469                                                           if (((word >> 23) & 0x1) == 0)
21470                                                             {
21471                                                               if (((word >> 29) & 0x1) == 0)
21472                                                                 {
21473                                                                   /* 33222222222211111111110000000000
21474                                                                      10987654321098765432109876543210
21475                                                                      xx0111100x1x0xx1101010xxxxxxxxxx
21476                                                                      fcvtns.  */
21477                                                                   return 487;
21478                                                                 }
21479                                                               else
21480                                                                 {
21481                                                                   /* 33222222222211111111110000000000
21482                                                                      10987654321098765432109876543210
21483                                                                      xx1111100x1x0xx1101010xxxxxxxxxx
21484                                                                      fcvtnu.  */
21485                                                                   return 517;
21486                                                                 }
21487                                                             }
21488                                                           else
21489                                                             {
21490                                                               if (((word >> 29) & 0x1) == 0)
21491                                                                 {
21492                                                                   /* 33222222222211111111110000000000
21493                                                                      10987654321098765432109876543210
21494                                                                      xx0111101x1x0xx1101010xxxxxxxxxx
21495                                                                      fcvtps.  */
21496                                                                   return 501;
21497                                                                 }
21498                                                               else
21499                                                                 {
21500                                                                   /* 33222222222211111111110000000000
21501                                                                      10987654321098765432109876543210
21502                                                                      xx1111101x1x0xx1101010xxxxxxxxxx
21503                                                                      fcvtpu.  */
21504                                                                   return 529;
21505                                                                 }
21506                                                             }
21507                                                         }
21508                                                       else
21509                                                         {
21510                                                           if (((word >> 23) & 0x1) == 0)
21511                                                             {
21512                                                               if (((word >> 29) & 0x1) == 0)
21513                                                                 {
21514                                                                   /* 33222222222211111111110000000000
21515                                                                      10987654321098765432109876543210
21516                                                                      xx0111100x1x1xx1101010xxxxxxxxxx
21517                                                                      fcvtns.  */
21518                                                                   return 488;
21519                                                                 }
21520                                                               else
21521                                                                 {
21522                                                                   /* 33222222222211111111110000000000
21523                                                                      10987654321098765432109876543210
21524                                                                      xx1111100x1x1xx1101010xxxxxxxxxx
21525                                                                      fcvtnu.  */
21526                                                                   return 518;
21527                                                                 }
21528                                                             }
21529                                                           else
21530                                                             {
21531                                                               if (((word >> 29) & 0x1) == 0)
21532                                                                 {
21533                                                                   /* 33222222222211111111110000000000
21534                                                                      10987654321098765432109876543210
21535                                                                      xx0111101x1x1xx1101010xxxxxxxxxx
21536                                                                      fcvtps.  */
21537                                                                   return 502;
21538                                                                 }
21539                                                               else
21540                                                                 {
21541                                                                   /* 33222222222211111111110000000000
21542                                                                      10987654321098765432109876543210
21543                                                                      xx1111101x1x1xx1101010xxxxxxxxxx
21544                                                                      fcvtpu.  */
21545                                                                   return 530;
21546                                                                 }
21547                                                             }
21548                                                         }
21549                                                     }
21550                                                 }
21551                                             }
21552                                           else
21553                                             {
21554                                               if (((word >> 15) & 0x1) == 0)
21555                                                 {
21556                                                   if (((word >> 29) & 0x1) == 0)
21557                                                     {
21558                                                       /* 33222222222211111111110000000000
21559                                                          10987654321098765432109876543210
21560                                                          xx011110xx1xxxxx011010xxxxxxxxxx
21561                                                          fmaxnm.  */
21562                                                       return 852;
21563                                                     }
21564                                                   else
21565                                                     {
21566                                                       /* 33222222222211111111110000000000
21567                                                          10987654321098765432109876543210
21568                                                          xx111110xx1xxxxx011010xxxxxxxxxx
21569                                                          fcvtxn.  */
21570                                                       return 516;
21571                                                     }
21572                                                 }
21573                                               else
21574                                                 {
21575                                                   if (((word >> 19) & 0x1) == 0)
21576                                                     {
21577                                                       /* 33222222222211111111110000000000
21578                                                          10987654321098765432109876543210
21579                                                          xxx11110xx1x0xxx111010xxxxxxxxxx
21580                                                          fcmlt.  */
21581                                                       return 499;
21582                                                     }
21583                                                   else
21584                                                     {
21585                                                       /* 33222222222211111111110000000000
21586                                                          10987654321098765432109876543210
21587                                                          xxx11110xx1x1xxx111010xxxxxxxxxx
21588                                                          fcmlt.  */
21589                                                       return 500;
21590                                                     }
21591                                                 }
21592                                             }
21593                                         }
21594                                     }
21595                                   else
21596                                     {
21597                                       if (((word >> 13) & 0x1) == 0)
21598                                         {
21599                                           if (((word >> 14) & 0x1) == 0)
21600                                             {
21601                                               if (((word >> 15) & 0x1) == 0)
21602                                                 {
21603                                                   if (((word >> 30) & 0x1) == 0)
21604                                                     {
21605                                                       /* 33222222222211111111110000000000
21606                                                          10987654321098765432109876543210
21607                                                          x0x11110xx1xxxxx000110xxxxxxxxxx
21608                                                          fdiv.  */
21609                                                       return 842;
21610                                                     }
21611                                                   else
21612                                                     {
21613                                                       /* 33222222222211111111110000000000
21614                                                          10987654321098765432109876543210
21615                                                          x1x11110xx1xxxxx000110xxxxxxxxxx
21616                                                          sha1su1.  */
21617                                                       return 676;
21618                                                     }
21619                                                 }
21620                                               else
21621                                                 {
21622                                                   if (((word >> 29) & 0x1) == 0)
21623                                                     {
21624                                                       /* 33222222222211111111110000000000
21625                                                          10987654321098765432109876543210
21626                                                          xx011110xx1xxxxx100110xxxxxxxxxx
21627                                                          cmeq.  */
21628                                                       return 483;
21629                                                     }
21630                                                   else
21631                                                     {
21632                                                       /* 33222222222211111111110000000000
21633                                                          10987654321098765432109876543210
21634                                                          xx111110xx1xxxxx100110xxxxxxxxxx
21635                                                          cmle.  */
21636                                                       return 512;
21637                                                     }
21638                                                 }
21639                                             }
21640                                           else
21641                                             {
21642                                               if (((word >> 15) & 0x1) == 0)
21643                                                 {
21644                                                   /* 33222222222211111111110000000000
21645                                                      10987654321098765432109876543210
21646                                                      xxx11110xx1xxxxx010110xxxxxxxxxx
21647                                                      fmin.  */
21648                                                   return 850;
21649                                                 }
21650                                               else
21651                                                 {
21652                                                   if (((word >> 16) & 0x1) == 0)
21653                                                     {
21654                                                       if (((word >> 19) & 0x1) == 0)
21655                                                         {
21656                                                           if (((word >> 20) & 0x1) == 0)
21657                                                             {
21658                                                               if (((word >> 29) & 0x1) == 0)
21659                                                                 {
21660                                                                   /* 33222222222211111111110000000000
21661                                                                      10987654321098765432109876543210
21662                                                                      xx011110xx100xx0110110xxxxxxxxxx
21663                                                                      fcmeq.  */
21664                                                                   return 497;
21665                                                                 }
21666                                                               else
21667                                                                 {
21668                                                                   /* 33222222222211111111110000000000
21669                                                                      10987654321098765432109876543210
21670                                                                      xx111110xx100xx0110110xxxxxxxxxx
21671                                                                      fcmle.  */
21672                                                                   return 527;
21673                                                                 }
21674                                                             }
21675                                                           else
21676                                                             {
21677                                                               if (((word >> 29) & 0x1) == 0)
21678                                                                 {
21679                                                                   /* 33222222222211111111110000000000
21680                                                                      10987654321098765432109876543210
21681                                                                      xx011110xx110xx0110110xxxxxxxxxx
21682                                                                      faddp.  */
21683                                                                   return 541;
21684                                                                 }
21685                                                               else
21686                                                                 {
21687                                                                   /* 33222222222211111111110000000000
21688                                                                      10987654321098765432109876543210
21689                                                                      xx111110xx110xx0110110xxxxxxxxxx
21690                                                                      faddp.  */
21691                                                                   return 540;
21692                                                                 }
21693                                                             }
21694                                                         }
21695                                                       else
21696                                                         {
21697                                                           if (((word >> 29) & 0x1) == 0)
21698                                                             {
21699                                                               /* 33222222222211111111110000000000
21700                                                                  10987654321098765432109876543210
21701                                                                  xx011110xx1x1xx0110110xxxxxxxxxx
21702                                                                  fcmeq.  */
21703                                                               return 498;
21704                                                             }
21705                                                           else
21706                                                             {
21707                                                               /* 33222222222211111111110000000000
21708                                                                  10987654321098765432109876543210
21709                                                                  xx111110xx1x1xx0110110xxxxxxxxxx
21710                                                                  fcmle.  */
21711                                                               return 528;
21712                                                             }
21713                                                         }
21714                                                     }
21715                                                   else
21716                                                     {
21717                                                       if (((word >> 19) & 0x1) == 0)
21718                                                         {
21719                                                           if (((word >> 23) & 0x1) == 0)
21720                                                             {
21721                                                               if (((word >> 29) & 0x1) == 0)
21722                                                                 {
21723                                                                   /* 33222222222211111111110000000000
21724                                                                      10987654321098765432109876543210
21725                                                                      xx0111100x1x0xx1110110xxxxxxxxxx
21726                                                                      scvtf.  */
21727                                                                   return 493;
21728                                                                 }
21729                                                               else
21730                                                                 {
21731                                                                   /* 33222222222211111111110000000000
21732                                                                      10987654321098765432109876543210
21733                                                                      xx1111100x1x0xx1110110xxxxxxxxxx
21734                                                                      ucvtf.  */
21735                                                                   return 523;
21736                                                                 }
21737                                                             }
21738                                                           else
21739                                                             {
21740                                                               if (((word >> 29) & 0x1) == 0)
21741                                                                 {
21742                                                                   /* 33222222222211111111110000000000
21743                                                                      10987654321098765432109876543210
21744                                                                      xx0111101x1x0xx1110110xxxxxxxxxx
21745                                                                      frecpe.  */
21746                                                                   return 505;
21747                                                                 }
21748                                                               else
21749                                                                 {
21750                                                                   /* 33222222222211111111110000000000
21751                                                                      10987654321098765432109876543210
21752                                                                      xx1111101x1x0xx1110110xxxxxxxxxx
21753                                                                      frsqrte.  */
21754                                                                   return 533;
21755                                                                 }
21756                                                             }
21757                                                         }
21758                                                       else
21759                                                         {
21760                                                           if (((word >> 23) & 0x1) == 0)
21761                                                             {
21762                                                               if (((word >> 29) & 0x1) == 0)
21763                                                                 {
21764                                                                   /* 33222222222211111111110000000000
21765                                                                      10987654321098765432109876543210
21766                                                                      xx0111100x1x1xx1110110xxxxxxxxxx
21767                                                                      scvtf.  */
21768                                                                   return 494;
21769                                                                 }
21770                                                               else
21771                                                                 {
21772                                                                   /* 33222222222211111111110000000000
21773                                                                      10987654321098765432109876543210
21774                                                                      xx1111100x1x1xx1110110xxxxxxxxxx
21775                                                                      ucvtf.  */
21776                                                                   return 524;
21777                                                                 }
21778                                                             }
21779                                                           else
21780                                                             {
21781                                                               if (((word >> 29) & 0x1) == 0)
21782                                                                 {
21783                                                                   /* 33222222222211111111110000000000
21784                                                                      10987654321098765432109876543210
21785                                                                      xx0111101x1x1xx1110110xxxxxxxxxx
21786                                                                      frecpe.  */
21787                                                                   return 506;
21788                                                                 }
21789                                                               else
21790                                                                 {
21791                                                                   /* 33222222222211111111110000000000
21792                                                                      10987654321098765432109876543210
21793                                                                      xx1111101x1x1xx1110110xxxxxxxxxx
21794                                                                      frsqrte.  */
21795                                                                   return 534;
21796                                                                 }
21797                                                             }
21798                                                         }
21799                                                     }
21800                                                 }
21801                                             }
21802                                         }
21803                                       else
21804                                         {
21805                                           if (((word >> 14) & 0x1) == 0)
21806                                             {
21807                                               if (((word >> 15) & 0x1) == 0)
21808                                                 {
21809                                                   if (((word >> 29) & 0x1) == 0)
21810                                                     {
21811                                                       if (((word >> 30) & 0x1) == 0)
21812                                                         {
21813                                                           /* 33222222222211111111110000000000
21814                                                              10987654321098765432109876543210
21815                                                              x0011110xx1xxxxx001110xxxxxxxxxx
21816                                                              fsub.  */
21817                                                           return 846;
21818                                                         }
21819                                                       else
21820                                                         {
21821                                                           /* 33222222222211111111110000000000
21822                                                              10987654321098765432109876543210
21823                                                              x1011110xx1xxxxx001110xxxxxxxxxx
21824                                                              suqadd.  */
21825                                                           return 480;
21826                                                         }
21827                                                     }
21828                                                   else
21829                                                     {
21830                                                       /* 33222222222211111111110000000000
21831                                                          10987654321098765432109876543210
21832                                                          xx111110xx1xxxxx001110xxxxxxxxxx
21833                                                          usqadd.  */
21834                                                       return 509;
21835                                                     }
21836                                                 }
21837                                               else
21838                                                 {
21839                                                   if (((word >> 16) & 0x1) == 0)
21840                                                     {
21841                                                       if (((word >> 29) & 0x1) == 0)
21842                                                         {
21843                                                           /* 33222222222211111111110000000000
21844                                                              10987654321098765432109876543210
21845                                                              xx011110xx1xxxx0101110xxxxxxxxxx
21846                                                              abs.  */
21847                                                           return 485;
21848                                                         }
21849                                                       else
21850                                                         {
21851                                                           /* 33222222222211111111110000000000
21852                                                              10987654321098765432109876543210
21853                                                              xx111110xx1xxxx0101110xxxxxxxxxx
21854                                                              neg.  */
21855                                                           return 513;
21856                                                         }
21857                                                     }
21858                                                   else
21859                                                     {
21860                                                       if (((word >> 19) & 0x1) == 0)
21861                                                         {
21862                                                           if (((word >> 20) & 0x1) == 0)
21863                                                             {
21864                                                               if (((word >> 23) & 0x1) == 0)
21865                                                                 {
21866                                                                   if (((word >> 29) & 0x1) == 0)
21867                                                                     {
21868                                                                       /* 33222222222211111111110000000000
21869                                                                          10987654321098765432109876543210
21870                                                                          xx0111100x100xx1101110xxxxxxxxxx
21871                                                                          fcvtms.  */
21872                                                                       return 489;
21873                                                                     }
21874                                                                   else
21875                                                                     {
21876                                                                       /* 33222222222211111111110000000000
21877                                                                          10987654321098765432109876543210
21878                                                                          xx1111100x100xx1101110xxxxxxxxxx
21879                                                                          fcvtmu.  */
21880                                                                       return 519;
21881                                                                     }
21882                                                                 }
21883                                                               else
21884                                                                 {
21885                                                                   if (((word >> 29) & 0x1) == 0)
21886                                                                     {
21887                                                                       /* 33222222222211111111110000000000
21888                                                                          10987654321098765432109876543210
21889                                                                          xx0111101x100xx1101110xxxxxxxxxx
21890                                                                          fcvtzs.  */
21891                                                                       return 503;
21892                                                                     }
21893                                                                   else
21894                                                                     {
21895                                                                       /* 33222222222211111111110000000000
21896                                                                          10987654321098765432109876543210
21897                                                                          xx1111101x100xx1101110xxxxxxxxxx
21898                                                                          fcvtzu.  */
21899                                                                       return 531;
21900                                                                     }
21901                                                                 }
21902                                                             }
21903                                                           else
21904                                                             {
21905                                                               /* 33222222222211111111110000000000
21906                                                                  10987654321098765432109876543210
21907                                                                  xxx11110xx110xx1101110xxxxxxxxxx
21908                                                                  addp.  */
21909                                                               return 537;
21910                                                             }
21911                                                         }
21912                                                       else
21913                                                         {
21914                                                           if (((word >> 23) & 0x1) == 0)
21915                                                             {
21916                                                               if (((word >> 29) & 0x1) == 0)
21917                                                                 {
21918                                                                   /* 33222222222211111111110000000000
21919                                                                      10987654321098765432109876543210
21920                                                                      xx0111100x1x1xx1101110xxxxxxxxxx
21921                                                                      fcvtms.  */
21922                                                                   return 490;
21923                                                                 }
21924                                                               else
21925                                                                 {
21926                                                                   /* 33222222222211111111110000000000
21927                                                                      10987654321098765432109876543210
21928                                                                      xx1111100x1x1xx1101110xxxxxxxxxx
21929                                                                      fcvtmu.  */
21930                                                                   return 520;
21931                                                                 }
21932                                                             }
21933                                                           else
21934                                                             {
21935                                                               if (((word >> 29) & 0x1) == 0)
21936                                                                 {
21937                                                                   /* 33222222222211111111110000000000
21938                                                                      10987654321098765432109876543210
21939                                                                      xx0111101x1x1xx1101110xxxxxxxxxx
21940                                                                      fcvtzs.  */
21941                                                                   return 504;
21942                                                                 }
21943                                                               else
21944                                                                 {
21945                                                                   /* 33222222222211111111110000000000
21946                                                                      10987654321098765432109876543210
21947                                                                      xx1111101x1x1xx1101110xxxxxxxxxx
21948                                                                      fcvtzu.  */
21949                                                                   return 532;
21950                                                                 }
21951                                                             }
21952                                                         }
21953                                                     }
21954                                                 }
21955                                             }
21956                                           else
21957                                             {
21958                                               if (((word >> 15) & 0x1) == 0)
21959                                                 {
21960                                                   if (((word >> 29) & 0x1) == 0)
21961                                                     {
21962                                                       if (((word >> 30) & 0x1) == 0)
21963                                                         {
21964                                                           /* 33222222222211111111110000000000
21965                                                              10987654321098765432109876543210
21966                                                              x0011110xx1xxxxx011110xxxxxxxxxx
21967                                                              fminnm.  */
21968                                                           return 854;
21969                                                         }
21970                                                       else
21971                                                         {
21972                                                           /* 33222222222211111111110000000000
21973                                                              10987654321098765432109876543210
21974                                                              x1011110xx1xxxxx011110xxxxxxxxxx
21975                                                              sqabs.  */
21976                                                           return 481;
21977                                                         }
21978                                                     }
21979                                                   else
21980                                                     {
21981                                                       /* 33222222222211111111110000000000
21982                                                          10987654321098765432109876543210
21983                                                          xx111110xx1xxxxx011110xxxxxxxxxx
21984                                                          sqneg.  */
21985                                                       return 510;
21986                                                     }
21987                                                 }
21988                                               else
21989                                                 {
21990                                                   if (((word >> 16) & 0x1) == 0)
21991                                                     {
21992                                                       if (((word >> 23) & 0x1) == 0)
21993                                                         {
21994                                                           if (((word >> 29) & 0x1) == 0)
21995                                                             {
21996                                                               /* 33222222222211111111110000000000
21997                                                                  10987654321098765432109876543210
21998                                                                  xx0111100x1xxxx0111110xxxxxxxxxx
21999                                                                  fmaxp.  */
22000                                                               return 543;
22001                                                             }
22002                                                           else
22003                                                             {
22004                                                               /* 33222222222211111111110000000000
22005                                                                  10987654321098765432109876543210
22006                                                                  xx1111100x1xxxx0111110xxxxxxxxxx
22007                                                                  fmaxp.  */
22008                                                               return 542;
22009                                                             }
22010                                                         }
22011                                                       else
22012                                                         {
22013                                                           if (((word >> 29) & 0x1) == 0)
22014                                                             {
22015                                                               /* 33222222222211111111110000000000
22016                                                                  10987654321098765432109876543210
22017                                                                  xx0111101x1xxxx0111110xxxxxxxxxx
22018                                                                  fminp.  */
22019                                                               return 547;
22020                                                             }
22021                                                           else
22022                                                             {
22023                                                               /* 33222222222211111111110000000000
22024                                                                  10987654321098765432109876543210
22025                                                                  xx1111101x1xxxx0111110xxxxxxxxxx
22026                                                                  fminp.  */
22027                                                               return 546;
22028                                                             }
22029                                                         }
22030                                                     }
22031                                                   else
22032                                                     {
22033                                                       if (((word >> 19) & 0x1) == 0)
22034                                                         {
22035                                                           /* 33222222222211111111110000000000
22036                                                              10987654321098765432109876543210
22037                                                              xxx11110xx1x0xx1111110xxxxxxxxxx
22038                                                              frecpx.  */
22039                                                           return 507;
22040                                                         }
22041                                                       else
22042                                                         {
22043                                                           /* 33222222222211111111110000000000
22044                                                              10987654321098765432109876543210
22045                                                              xxx11110xx1x1xx1111110xxxxxxxxxx
22046                                                              frecpx.  */
22047                                                           return 508;
22048                                                         }
22049                                                     }
22050                                                 }
22051                                             }
22052                                         }
22053                                     }
22054                                 }
22055                             }
22056                           else
22057                             {
22058                               if (((word >> 11) & 0x1) == 0)
22059                                 {
22060                                   if (((word >> 29) & 0x1) == 0)
22061                                     {
22062                                       if (((word >> 30) & 0x1) == 0)
22063                                         {
22064                                           if (((word >> 4) & 0x1) == 0)
22065                                             {
22066                                               /* 33222222222211111111110000000000
22067                                                  10987654321098765432109876543210
22068                                                  x0011110xx1xxxxxxxxx01xxxxx0xxxx
22069                                                  fccmp.  */
22070                                               return 799;
22071                                             }
22072                                           else
22073                                             {
22074                                               /* 33222222222211111111110000000000
22075                                                  10987654321098765432109876543210
22076                                                  x0011110xx1xxxxxxxxx01xxxxx1xxxx
22077                                                  fccmpe.  */
22078                                               return 801;
22079                                             }
22080                                         }
22081                                       else
22082                                         {
22083                                           if (((word >> 12) & 0x1) == 0)
22084                                             {
22085                                               if (((word >> 13) & 0x1) == 0)
22086                                                 {
22087                                                   if (((word >> 14) & 0x1) == 0)
22088                                                     {
22089                                                       /* 33222222222211111111110000000000
22090                                                          10987654321098765432109876543210
22091                                                          x1011110xx1xxxxxx00001xxxxxxxxxx
22092                                                          add.  */
22093                                                       return 565;
22094                                                     }
22095                                                   else
22096                                                     {
22097                                                       /* 33222222222211111111110000000000
22098                                                          10987654321098765432109876543210
22099                                                          x1011110xx1xxxxxx10001xxxxxxxxxx
22100                                                          sshl.  */
22101                                                       return 563;
22102                                                     }
22103                                                 }
22104                                               else
22105                                                 {
22106                                                   /* 33222222222211111111110000000000
22107                                                      10987654321098765432109876543210
22108                                                      x1011110xx1xxxxxxx1001xxxxxxxxxx
22109                                                      fcmeq.  */
22110                                                   return 555;
22111                                                 }
22112                                             }
22113                                           else
22114                                             {
22115                                               if (((word >> 13) & 0x1) == 0)
22116                                                 {
22117                                                   /* 33222222222211111111110000000000
22118                                                      10987654321098765432109876543210
22119                                                      x1011110xx1xxxxxxx0101xxxxxxxxxx
22120                                                      srshl.  */
22121                                                   return 564;
22122                                                 }
22123                                               else
22124                                                 {
22125                                                   if (((word >> 15) & 0x1) == 0)
22126                                                     {
22127                                                       /* 33222222222211111111110000000000
22128                                                          10987654321098765432109876543210
22129                                                          x1011110xx1xxxxx0x1101xxxxxxxxxx
22130                                                          cmgt.  */
22131                                                       return 561;
22132                                                     }
22133                                                   else
22134                                                     {
22135                                                       /* 33222222222211111111110000000000
22136                                                          10987654321098765432109876543210
22137                                                          x1011110xx1xxxxx1x1101xxxxxxxxxx
22138                                                          sqdmulh.  */
22139                                                       return 552;
22140                                                     }
22141                                                 }
22142                                             }
22143                                         }
22144                                     }
22145                                   else
22146                                     {
22147                                       if (((word >> 12) & 0x1) == 0)
22148                                         {
22149                                           if (((word >> 13) & 0x1) == 0)
22150                                             {
22151                                               if (((word >> 14) & 0x1) == 0)
22152                                                 {
22153                                                   /* 33222222222211111111110000000000
22154                                                      10987654321098765432109876543210
22155                                                      xx111110xx1xxxxxx00001xxxxxxxxxx
22156                                                      sub.  */
22157                                                   return 586;
22158                                                 }
22159                                               else
22160                                                 {
22161                                                   /* 33222222222211111111110000000000
22162                                                      10987654321098765432109876543210
22163                                                      xx111110xx1xxxxxx10001xxxxxxxxxx
22164                                                      ushl.  */
22165                                                   return 584;
22166                                                 }
22167                                             }
22168                                           else
22169                                             {
22170                                               if (((word >> 23) & 0x1) == 0)
22171                                                 {
22172                                                   /* 33222222222211111111110000000000
22173                                                      10987654321098765432109876543210
22174                                                      xx1111100x1xxxxxxx1001xxxxxxxxxx
22175                                                      fcmge.  */
22176                                                   return 572;
22177                                                 }
22178                                               else
22179                                                 {
22180                                                   /* 33222222222211111111110000000000
22181                                                      10987654321098765432109876543210
22182                                                      xx1111101x1xxxxxxx1001xxxxxxxxxx
22183                                                      fcmgt.  */
22184                                                   return 578;
22185                                                 }
22186                                             }
22187                                         }
22188                                       else
22189                                         {
22190                                           if (((word >> 13) & 0x1) == 0)
22191                                             {
22192                                               if (((word >> 15) & 0x1) == 0)
22193                                                 {
22194                                                   /* 33222222222211111111110000000000
22195                                                      10987654321098765432109876543210
22196                                                      xx111110xx1xxxxx0x0101xxxxxxxxxx
22197                                                      urshl.  */
22198                                                   return 585;
22199                                                 }
22200                                               else
22201                                                 {
22202                                                   /* 33222222222211111111110000000000
22203                                                      10987654321098765432109876543210
22204                                                      xx111110xx1xxxxx1x0101xxxxxxxxxx
22205                                                      fabd.  */
22206                                                   return 576;
22207                                                 }
22208                                             }
22209                                           else
22210                                             {
22211                                               if (((word >> 15) & 0x1) == 0)
22212                                                 {
22213                                                   /* 33222222222211111111110000000000
22214                                                      10987654321098765432109876543210
22215                                                      xx111110xx1xxxxx0x1101xxxxxxxxxx
22216                                                      cmhi.  */
22217                                                   return 582;
22218                                                 }
22219                                               else
22220                                                 {
22221                                                   /* 33222222222211111111110000000000
22222                                                      10987654321098765432109876543210
22223                                                      xx111110xx1xxxxx1x1101xxxxxxxxxx
22224                                                      sqrdmulh.  */
22225                                                   return 571;
22226                                                 }
22227                                             }
22228                                         }
22229                                     }
22230                                 }
22231                               else
22232                                 {
22233                                   if (((word >> 29) & 0x1) == 0)
22234                                     {
22235                                       if (((word >> 30) & 0x1) == 0)
22236                                         {
22237                                           /* 33222222222211111111110000000000
22238                                              10987654321098765432109876543210
22239                                              x0011110xx1xxxxxxxxx11xxxxxxxxxx
22240                                              fcsel.  */
22241                                           return 868;
22242                                         }
22243                                       else
22244                                         {
22245                                           if (((word >> 12) & 0x1) == 0)
22246                                             {
22247                                               if (((word >> 13) & 0x1) == 0)
22248                                                 {
22249                                                   if (((word >> 14) & 0x1) == 0)
22250                                                     {
22251                                                       if (((word >> 15) & 0x1) == 0)
22252                                                         {
22253                                                           /* 33222222222211111111110000000000
22254                                                              10987654321098765432109876543210
22255                                                              x1011110xx1xxxxx000011xxxxxxxxxx
22256                                                              sqadd.  */
22257                                                           return 548;
22258                                                         }
22259                                                       else
22260                                                         {
22261                                                           /* 33222222222211111111110000000000
22262                                                              10987654321098765432109876543210
22263                                                              x1011110xx1xxxxx100011xxxxxxxxxx
22264                                                              cmtst.  */
22265                                                           return 566;
22266                                                         }
22267                                                     }
22268                                                   else
22269                                                     {
22270                                                       /* 33222222222211111111110000000000
22271                                                          10987654321098765432109876543210
22272                                                          x1011110xx1xxxxxx10011xxxxxxxxxx
22273                                                          sqshl.  */
22274                                                       return 550;
22275                                                     }
22276                                                 }
22277                                               else
22278                                                 {
22279                                                   /* 33222222222211111111110000000000
22280                                                      10987654321098765432109876543210
22281                                                      x1011110xx1xxxxxxx1011xxxxxxxxxx
22282                                                      sqsub.  */
22283                                                   return 549;
22284                                                 }
22285                                             }
22286                                           else
22287                                             {
22288                                               if (((word >> 13) & 0x1) == 0)
22289                                                 {
22290                                                   if (((word >> 15) & 0x1) == 0)
22291                                                     {
22292                                                       /* 33222222222211111111110000000000
22293                                                          10987654321098765432109876543210
22294                                                          x1011110xx1xxxxx0x0111xxxxxxxxxx
22295                                                          sqrshl.  */
22296                                                       return 551;
22297                                                     }
22298                                                   else
22299                                                     {
22300                                                       /* 33222222222211111111110000000000
22301                                                          10987654321098765432109876543210
22302                                                          x1011110xx1xxxxx1x0111xxxxxxxxxx
22303                                                          fmulx.  */
22304                                                       return 553;
22305                                                     }
22306                                                 }
22307                                               else
22308                                                 {
22309                                                   if (((word >> 14) & 0x1) == 0)
22310                                                     {
22311                                                       /* 33222222222211111111110000000000
22312                                                          10987654321098765432109876543210
22313                                                          x1011110xx1xxxxxx01111xxxxxxxxxx
22314                                                          cmge.  */
22315                                                       return 562;
22316                                                     }
22317                                                   else
22318                                                     {
22319                                                       if (((word >> 23) & 0x1) == 0)
22320                                                         {
22321                                                           /* 33222222222211111111110000000000
22322                                                              10987654321098765432109876543210
22323                                                              x10111100x1xxxxxx11111xxxxxxxxxx
22324                                                              frecps.  */
22325                                                           return 557;
22326                                                         }
22327                                                       else
22328                                                         {
22329                                                           /* 33222222222211111111110000000000
22330                                                              10987654321098765432109876543210
22331                                                              x10111101x1xxxxxx11111xxxxxxxxxx
22332                                                              frsqrts.  */
22333                                                           return 559;
22334                                                         }
22335                                                     }
22336                                                 }
22337                                             }
22338                                         }
22339                                     }
22340                                   else
22341                                     {
22342                                       if (((word >> 12) & 0x1) == 0)
22343                                         {
22344                                           if (((word >> 13) & 0x1) == 0)
22345                                             {
22346                                               if (((word >> 14) & 0x1) == 0)
22347                                                 {
22348                                                   if (((word >> 15) & 0x1) == 0)
22349                                                     {
22350                                                       /* 33222222222211111111110000000000
22351                                                          10987654321098765432109876543210
22352                                                          xx111110xx1xxxxx000011xxxxxxxxxx
22353                                                          uqadd.  */
22354                                                       return 567;
22355                                                     }
22356                                                   else
22357                                                     {
22358                                                       /* 33222222222211111111110000000000
22359                                                          10987654321098765432109876543210
22360                                                          xx111110xx1xxxxx100011xxxxxxxxxx
22361                                                          cmeq.  */
22362                                                       return 587;
22363                                                     }
22364                                                 }
22365                                               else
22366                                                 {
22367                                                   /* 33222222222211111111110000000000
22368                                                      10987654321098765432109876543210
22369                                                      xx111110xx1xxxxxx10011xxxxxxxxxx
22370                                                      uqshl.  */
22371                                                   return 569;
22372                                                 }
22373                                             }
22374                                           else
22375                                             {
22376                                               if (((word >> 14) & 0x1) == 0)
22377                                                 {
22378                                                   /* 33222222222211111111110000000000
22379                                                      10987654321098765432109876543210
22380                                                      xx111110xx1xxxxxx01011xxxxxxxxxx
22381                                                      uqsub.  */
22382                                                   return 568;
22383                                                 }
22384                                               else
22385                                                 {
22386                                                   if (((word >> 23) & 0x1) == 0)
22387                                                     {
22388                                                       /* 33222222222211111111110000000000
22389                                                          10987654321098765432109876543210
22390                                                          xx1111100x1xxxxxx11011xxxxxxxxxx
22391                                                          facge.  */
22392                                                       return 574;
22393                                                     }
22394                                                   else
22395                                                     {
22396                                                       /* 33222222222211111111110000000000
22397                                                          10987654321098765432109876543210
22398                                                          xx1111101x1xxxxxx11011xxxxxxxxxx
22399                                                          facgt.  */
22400                                                       return 580;
22401                                                     }
22402                                                 }
22403                                             }
22404                                         }
22405                                       else
22406                                         {
22407                                           if (((word >> 13) & 0x1) == 0)
22408                                             {
22409                                               /* 33222222222211111111110000000000
22410                                                  10987654321098765432109876543210
22411                                                  xx111110xx1xxxxxxx0111xxxxxxxxxx
22412                                                  uqrshl.  */
22413                                               return 570;
22414                                             }
22415                                           else
22416                                             {
22417                                               /* 33222222222211111111110000000000
22418                                                  10987654321098765432109876543210
22419                                                  xx111110xx1xxxxxxx1111xxxxxxxxxx
22420                                                  cmhs.  */
22421                                               return 583;
22422                                             }
22423                                         }
22424                                     }
22425                                 }
22426                             }
22427                         }
22428                     }
22429                 }
22430               else
22431                 {
22432                   if (((word >> 15) & 0x1) == 0)
22433                     {
22434                       if (((word >> 28) & 0x1) == 0)
22435                         {
22436                           if (((word >> 10) & 0x1) == 0)
22437                             {
22438                               if (((word >> 12) & 0x1) == 0)
22439                                 {
22440                                   if (((word >> 13) & 0x1) == 0)
22441                                     {
22442                                       if (((word >> 14) & 0x1) == 0)
22443                                         {
22444                                           if (((word >> 29) & 0x1) == 0)
22445                                             {
22446                                               if (((word >> 30) & 0x1) == 0)
22447                                                 {
22448                                                   /* 33222222222211111111110000000000
22449                                                      10987654321098765432109876543210
22450                                                      x0001111xxxxxxxx0000x0xxxxxxxxxx
22451                                                      fmlal.  */
22452                                                   return 2440;
22453                                                 }
22454                                               else
22455                                                 {
22456                                                   /* 33222222222211111111110000000000
22457                                                      10987654321098765432109876543210
22458                                                      x1001111xxxxxxxx0000x0xxxxxxxxxx
22459                                                      fmlal.  */
22460                                                   return 2444;
22461                                                 }
22462                                             }
22463                                           else
22464                                             {
22465                                               /* 33222222222211111111110000000000
22466                                                  10987654321098765432109876543210
22467                                                  xx101111xxxxxxxx0000x0xxxxxxxxxx
22468                                                  mla.  */
22469                                               return 119;
22470                                             }
22471                                         }
22472                                       else
22473                                         {
22474                                           if (((word >> 29) & 0x1) == 0)
22475                                             {
22476                                               if (((word >> 30) & 0x1) == 0)
22477                                                 {
22478                                                   /* 33222222222211111111110000000000
22479                                                      10987654321098765432109876543210
22480                                                      x0001111xxxxxxxx0100x0xxxxxxxxxx
22481                                                      fmlsl.  */
22482                                                   return 2441;
22483                                                 }
22484                                               else
22485                                                 {
22486                                                   /* 33222222222211111111110000000000
22487                                                      10987654321098765432109876543210
22488                                                      x1001111xxxxxxxx0100x0xxxxxxxxxx
22489                                                      fmlsl.  */
22490                                                   return 2445;
22491                                                 }
22492                                             }
22493                                           else
22494                                             {
22495                                               /* 33222222222211111111110000000000
22496                                                  10987654321098765432109876543210
22497                                                  xx101111xxxxxxxx0100x0xxxxxxxxxx
22498                                                  mls.  */
22499                                               return 122;
22500                                             }
22501                                         }
22502                                     }
22503                                   else
22504                                     {
22505                                       if (((word >> 14) & 0x1) == 0)
22506                                         {
22507                                           if (((word >> 29) & 0x1) == 0)
22508                                             {
22509                                               if (((word >> 30) & 0x1) == 0)
22510                                                 {
22511                                                   /* 33222222222211111111110000000000
22512                                                      10987654321098765432109876543210
22513                                                      x0001111xxxxxxxx0010x0xxxxxxxxxx
22514                                                      smlal.  */
22515                                                   return 98;
22516                                                 }
22517                                               else
22518                                                 {
22519                                                   /* 33222222222211111111110000000000
22520                                                      10987654321098765432109876543210
22521                                                      x1001111xxxxxxxx0010x0xxxxxxxxxx
22522                                                      smlal2.  */
22523                                                   return 99;
22524                                                 }
22525                                             }
22526                                           else
22527                                             {
22528                                               if (((word >> 30) & 0x1) == 0)
22529                                                 {
22530                                                   /* 33222222222211111111110000000000
22531                                                      10987654321098765432109876543210
22532                                                      x0101111xxxxxxxx0010x0xxxxxxxxxx
22533                                                      umlal.  */
22534                                                   return 120;
22535                                                 }
22536                                               else
22537                                                 {
22538                                                   /* 33222222222211111111110000000000
22539                                                      10987654321098765432109876543210
22540                                                      x1101111xxxxxxxx0010x0xxxxxxxxxx
22541                                                      umlal2.  */
22542                                                   return 121;
22543                                                 }
22544                                             }
22545                                         }
22546                                       else
22547                                         {
22548                                           if (((word >> 29) & 0x1) == 0)
22549                                             {
22550                                               if (((word >> 30) & 0x1) == 0)
22551                                                 {
22552                                                   /* 33222222222211111111110000000000
22553                                                      10987654321098765432109876543210
22554                                                      x0001111xxxxxxxx0110x0xxxxxxxxxx
22555                                                      smlsl.  */
22556                                                   return 102;
22557                                                 }
22558                                               else
22559                                                 {
22560                                                   /* 33222222222211111111110000000000
22561                                                      10987654321098765432109876543210
22562                                                      x1001111xxxxxxxx0110x0xxxxxxxxxx
22563                                                      smlsl2.  */
22564                                                   return 103;
22565                                                 }
22566                                             }
22567                                           else
22568                                             {
22569                                               if (((word >> 30) & 0x1) == 0)
22570                                                 {
22571                                                   /* 33222222222211111111110000000000
22572                                                      10987654321098765432109876543210
22573                                                      x0101111xxxxxxxx0110x0xxxxxxxxxx
22574                                                      umlsl.  */
22575                                                   return 123;
22576                                                 }
22577                                               else
22578                                                 {
22579                                                   /* 33222222222211111111110000000000
22580                                                      10987654321098765432109876543210
22581                                                      x1101111xxxxxxxx0110x0xxxxxxxxxx
22582                                                      umlsl2.  */
22583                                                   return 124;
22584                                                 }
22585                                             }
22586                                         }
22587                                     }
22588                                 }
22589                               else
22590                                 {
22591                                   if (((word >> 29) & 0x1) == 0)
22592                                     {
22593                                       if (((word >> 13) & 0x1) == 0)
22594                                         {
22595                                           if (((word >> 14) & 0x1) == 0)
22596                                             {
22597                                               if (((word >> 23) & 0x1) == 0)
22598                                                 {
22599                                                   /* 33222222222211111111110000000000
22600                                                      10987654321098765432109876543210
22601                                                      xx0011110xxxxxxx0001x0xxxxxxxxxx
22602                                                      fmla.  */
22603                                                   return 114;
22604                                                 }
22605                                               else
22606                                                 {
22607                                                   /* 33222222222211111111110000000000
22608                                                      10987654321098765432109876543210
22609                                                      xx0011111xxxxxxx0001x0xxxxxxxxxx
22610                                                      fmla.  */
22611                                                   return 113;
22612                                                 }
22613                                             }
22614                                           else
22615                                             {
22616                                               if (((word >> 23) & 0x1) == 0)
22617                                                 {
22618                                                   /* 33222222222211111111110000000000
22619                                                      10987654321098765432109876543210
22620                                                      xx0011110xxxxxxx0101x0xxxxxxxxxx
22621                                                      fmls.  */
22622                                                   return 116;
22623                                                 }
22624                                               else
22625                                                 {
22626                                                   /* 33222222222211111111110000000000
22627                                                      10987654321098765432109876543210
22628                                                      xx0011111xxxxxxx0101x0xxxxxxxxxx
22629                                                      fmls.  */
22630                                                   return 115;
22631                                                 }
22632                                             }
22633                                         }
22634                                       else
22635                                         {
22636                                           if (((word >> 14) & 0x1) == 0)
22637                                             {
22638                                               if (((word >> 30) & 0x1) == 0)
22639                                                 {
22640                                                   /* 33222222222211111111110000000000
22641                                                      10987654321098765432109876543210
22642                                                      x0001111xxxxxxxx0011x0xxxxxxxxxx
22643                                                      sqdmlal.  */
22644                                                   return 100;
22645                                                 }
22646                                               else
22647                                                 {
22648                                                   /* 33222222222211111111110000000000
22649                                                      10987654321098765432109876543210
22650                                                      x1001111xxxxxxxx0011x0xxxxxxxxxx
22651                                                      sqdmlal2.  */
22652                                                   return 101;
22653                                                 }
22654                                             }
22655                                           else
22656                                             {
22657                                               if (((word >> 30) & 0x1) == 0)
22658                                                 {
22659                                                   /* 33222222222211111111110000000000
22660                                                      10987654321098765432109876543210
22661                                                      x0001111xxxxxxxx0111x0xxxxxxxxxx
22662                                                      sqdmlsl.  */
22663                                                   return 104;
22664                                                 }
22665                                               else
22666                                                 {
22667                                                   /* 33222222222211111111110000000000
22668                                                      10987654321098765432109876543210
22669                                                      x1001111xxxxxxxx0111x0xxxxxxxxxx
22670                                                      sqdmlsl2.  */
22671                                                   return 105;
22672                                                 }
22673                                             }
22674                                         }
22675                                     }
22676                                   else
22677                                     {
22678                                       /* 33222222222211111111110000000000
22679                                          10987654321098765432109876543210
22680                                          xx101111xxxxxxxx0xx1x0xxxxxxxxxx
22681                                          fcmla.  */
22682                                       return 131;
22683                                     }
22684                                 }
22685                             }
22686                           else
22687                             {
22688                               if (((word >> 12) & 0x1) == 0)
22689                                 {
22690                                   if (((word >> 29) & 0x1) == 0)
22691                                     {
22692                                       /* 33222222222211111111110000000000
22693                                          10987654321098765432109876543210
22694                                          xx001111xxxxxxxx0xx0x1xxxxxxxxxx
22695                                          movi.  */
22696                                       return 133;
22697                                     }
22698                                   else
22699                                     {
22700                                       /* 33222222222211111111110000000000
22701                                          10987654321098765432109876543210
22702                                          xx101111xxxxxxxx0xx0x1xxxxxxxxxx
22703                                          mvni.  */
22704                                       return 141;
22705                                     }
22706                                 }
22707                               else
22708                                 {
22709                                   if (((word >> 29) & 0x1) == 0)
22710                                     {
22711                                       /* 33222222222211111111110000000000
22712                                          10987654321098765432109876543210
22713                                          xx001111xxxxxxxx0xx1x1xxxxxxxxxx
22714                                          orr.  */
22715                                       return 134;
22716                                     }
22717                                   else
22718                                     {
22719                                       /* 33222222222211111111110000000000
22720                                          10987654321098765432109876543210
22721                                          xx101111xxxxxxxx0xx1x1xxxxxxxxxx
22722                                          bic.  */
22723                                       return 142;
22724                                     }
22725                                 }
22726                             }
22727                         }
22728                       else
22729                         {
22730                           if (((word >> 29) & 0x1) == 0)
22731                             {
22732                               if (((word >> 30) & 0x1) == 0)
22733                                 {
22734                                   if (((word >> 21) & 0x1) == 0)
22735                                     {
22736                                       /* 33222222222211111111110000000000
22737                                          10987654321098765432109876543210
22738                                          x0011111xx0xxxxx0xxxxxxxxxxxxxxx
22739                                          fmadd.  */
22740                                       return 858;
22741                                     }
22742                                   else
22743                                     {
22744                                       /* 33222222222211111111110000000000
22745                                          10987654321098765432109876543210
22746                                          x0011111xx1xxxxx0xxxxxxxxxxxxxxx
22747                                          fnmadd.  */
22748                                       return 862;
22749                                     }
22750                                 }
22751                               else
22752                                 {
22753                                   if (((word >> 10) & 0x1) == 0)
22754                                     {
22755                                       if (((word >> 13) & 0x1) == 0)
22756                                         {
22757                                           if (((word >> 14) & 0x1) == 0)
22758                                             {
22759                                               if (((word >> 23) & 0x1) == 0)
22760                                                 {
22761                                                   /* 33222222222211111111110000000000
22762                                                      10987654321098765432109876543210
22763                                                      x10111110xxxxxxx000xx0xxxxxxxxxx
22764                                                      fmla.  */
22765                                                   return 431;
22766                                                 }
22767                                               else
22768                                                 {
22769                                                   /* 33222222222211111111110000000000
22770                                                      10987654321098765432109876543210
22771                                                      x10111111xxxxxxx000xx0xxxxxxxxxx
22772                                                      fmla.  */
22773                                                   return 430;
22774                                                 }
22775                                             }
22776                                           else
22777                                             {
22778                                               if (((word >> 23) & 0x1) == 0)
22779                                                 {
22780                                                   /* 33222222222211111111110000000000
22781                                                      10987654321098765432109876543210
22782                                                      x10111110xxxxxxx010xx0xxxxxxxxxx
22783                                                      fmls.  */
22784                                                   return 433;
22785                                                 }
22786                                               else
22787                                                 {
22788                                                   /* 33222222222211111111110000000000
22789                                                      10987654321098765432109876543210
22790                                                      x10111111xxxxxxx010xx0xxxxxxxxxx
22791                                                      fmls.  */
22792                                                   return 432;
22793                                                 }
22794                                             }
22795                                         }
22796                                       else
22797                                         {
22798                                           if (((word >> 14) & 0x1) == 0)
22799                                             {
22800                                               /* 33222222222211111111110000000000
22801                                                  10987654321098765432109876543210
22802                                                  x1011111xxxxxxxx001xx0xxxxxxxxxx
22803                                                  sqdmlal.  */
22804                                               return 425;
22805                                             }
22806                                           else
22807                                             {
22808                                               /* 33222222222211111111110000000000
22809                                                  10987654321098765432109876543210
22810                                                  x1011111xxxxxxxx011xx0xxxxxxxxxx
22811                                                  sqdmlsl.  */
22812                                               return 426;
22813                                             }
22814                                         }
22815                                     }
22816                                   else
22817                                     {
22818                                       if (((word >> 12) & 0x1) == 0)
22819                                         {
22820                                           if (((word >> 13) & 0x1) == 0)
22821                                             {
22822                                               /* 33222222222211111111110000000000
22823                                                  10987654321098765432109876543210
22824                                                  x1011111xxxxxxxx0x00x1xxxxxxxxxx
22825                                                  sshr.  */
22826                                               return 590;
22827                                             }
22828                                           else
22829                                             {
22830                                               /* 33222222222211111111110000000000
22831                                                  10987654321098765432109876543210
22832                                                  x1011111xxxxxxxx0x10x1xxxxxxxxxx
22833                                                  srshr.  */
22834                                               return 592;
22835                                             }
22836                                         }
22837                                       else
22838                                         {
22839                                           if (((word >> 13) & 0x1) == 0)
22840                                             {
22841                                               if (((word >> 14) & 0x1) == 0)
22842                                                 {
22843                                                   /* 33222222222211111111110000000000
22844                                                      10987654321098765432109876543210
22845                                                      x1011111xxxxxxxx0001x1xxxxxxxxxx
22846                                                      ssra.  */
22847                                                   return 591;
22848                                                 }
22849                                               else
22850                                                 {
22851                                                   /* 33222222222211111111110000000000
22852                                                      10987654321098765432109876543210
22853                                                      x1011111xxxxxxxx0101x1xxxxxxxxxx
22854                                                      shl.  */
22855                                                   return 594;
22856                                                 }
22857                                             }
22858                                           else
22859                                             {
22860                                               if (((word >> 14) & 0x1) == 0)
22861                                                 {
22862                                                   /* 33222222222211111111110000000000
22863                                                      10987654321098765432109876543210
22864                                                      x1011111xxxxxxxx0011x1xxxxxxxxxx
22865                                                      srsra.  */
22866                                                   return 593;
22867                                                 }
22868                                               else
22869                                                 {
22870                                                   /* 33222222222211111111110000000000
22871                                                      10987654321098765432109876543210
22872                                                      x1011111xxxxxxxx0111x1xxxxxxxxxx
22873                                                      sqshl.  */
22874                                                   return 595;
22875                                                 }
22876                                             }
22877                                         }
22878                                     }
22879                                 }
22880                             }
22881                           else
22882                             {
22883                               if (((word >> 12) & 0x1) == 0)
22884                                 {
22885                                   if (((word >> 13) & 0x1) == 0)
22886                                     {
22887                                       if (((word >> 14) & 0x1) == 0)
22888                                         {
22889                                           /* 33222222222211111111110000000000
22890                                              10987654321098765432109876543210
22891                                              xx111111xxxxxxxx0000xxxxxxxxxxxx
22892                                              ushr.  */
22893                                           return 602;
22894                                         }
22895                                       else
22896                                         {
22897                                           /* 33222222222211111111110000000000
22898                                              10987654321098765432109876543210
22899                                              xx111111xxxxxxxx0100xxxxxxxxxxxx
22900                                              sri.  */
22901                                           return 606;
22902                                         }
22903                                     }
22904                                   else
22905                                     {
22906                                       if (((word >> 14) & 0x1) == 0)
22907                                         {
22908                                           /* 33222222222211111111110000000000
22909                                              10987654321098765432109876543210
22910                                              xx111111xxxxxxxx0010xxxxxxxxxxxx
22911                                              urshr.  */
22912                                           return 604;
22913                                         }
22914                                       else
22915                                         {
22916                                           /* 33222222222211111111110000000000
22917                                              10987654321098765432109876543210
22918                                              xx111111xxxxxxxx0110xxxxxxxxxxxx
22919                                              sqshlu.  */
22920                                           return 608;
22921                                         }
22922                                     }
22923                                 }
22924                               else
22925                                 {
22926                                   if (((word >> 13) & 0x1) == 0)
22927                                     {
22928                                       if (((word >> 14) & 0x1) == 0)
22929                                         {
22930                                           /* 33222222222211111111110000000000
22931                                              10987654321098765432109876543210
22932                                              xx111111xxxxxxxx0001xxxxxxxxxxxx
22933                                              usra.  */
22934                                           return 603;
22935                                         }
22936                                       else
22937                                         {
22938                                           /* 33222222222211111111110000000000
22939                                              10987654321098765432109876543210
22940                                              xx111111xxxxxxxx0101xxxxxxxxxxxx
22941                                              sli.  */
22942                                           return 607;
22943                                         }
22944                                     }
22945                                   else
22946                                     {
22947                                       if (((word >> 14) & 0x1) == 0)
22948                                         {
22949                                           /* 33222222222211111111110000000000
22950                                              10987654321098765432109876543210
22951                                              xx111111xxxxxxxx0011xxxxxxxxxxxx
22952                                              ursra.  */
22953                                           return 605;
22954                                         }
22955                                       else
22956                                         {
22957                                           /* 33222222222211111111110000000000
22958                                              10987654321098765432109876543210
22959                                              xx111111xxxxxxxx0111xxxxxxxxxxxx
22960                                              uqshl.  */
22961                                           return 609;
22962                                         }
22963                                     }
22964                                 }
22965                             }
22966                         }
22967                     }
22968                   else
22969                     {
22970                       if (((word >> 28) & 0x1) == 0)
22971                         {
22972                           if (((word >> 10) & 0x1) == 0)
22973                             {
22974                               if (((word >> 12) & 0x1) == 0)
22975                                 {
22976                                   if (((word >> 13) & 0x1) == 0)
22977                                     {
22978                                       if (((word >> 14) & 0x1) == 0)
22979                                         {
22980                                           if (((word >> 29) & 0x1) == 0)
22981                                             {
22982                                               /* 33222222222211111111110000000000
22983                                                  10987654321098765432109876543210
22984                                                  xx001111xxxxxxxx1000x0xxxxxxxxxx
22985                                                  mul.  */
22986                                               return 106;
22987                                             }
22988                                           else
22989                                             {
22990                                               if (((word >> 30) & 0x1) == 0)
22991                                                 {
22992                                                   /* 33222222222211111111110000000000
22993                                                      10987654321098765432109876543210
22994                                                      x0101111xxxxxxxx1000x0xxxxxxxxxx
22995                                                      fmlal2.  */
22996                                                   return 2442;
22997                                                 }
22998                                               else
22999                                                 {
23000                                                   /* 33222222222211111111110000000000
23001                                                      10987654321098765432109876543210
23002                                                      x1101111xxxxxxxx1000x0xxxxxxxxxx
23003                                                      fmlal2.  */
23004                                                   return 2446;
23005                                                 }
23006                                             }
23007                                         }
23008                                       else
23009                                         {
23010                                           if (((word >> 29) & 0x1) == 0)
23011                                             {
23012                                               /* 33222222222211111111110000000000
23013                                                  10987654321098765432109876543210
23014                                                  xx001111xxxxxxxx1100x0xxxxxxxxxx
23015                                                  sqdmulh.  */
23016                                               return 111;
23017                                             }
23018                                           else
23019                                             {
23020                                               if (((word >> 30) & 0x1) == 0)
23021                                                 {
23022                                                   /* 33222222222211111111110000000000
23023                                                      10987654321098765432109876543210
23024                                                      x0101111xxxxxxxx1100x0xxxxxxxxxx
23025                                                      fmlsl2.  */
23026                                                   return 2443;
23027                                                 }
23028                                               else
23029                                                 {
23030                                                   /* 33222222222211111111110000000000
23031                                                      10987654321098765432109876543210
23032                                                      x1101111xxxxxxxx1100x0xxxxxxxxxx
23033                                                      fmlsl2.  */
23034                                                   return 2447;
23035                                                 }
23036                                             }
23037                                         }
23038                                     }
23039                                   else
23040                                     {
23041                                       if (((word >> 14) & 0x1) == 0)
23042                                         {
23043                                           if (((word >> 29) & 0x1) == 0)
23044                                             {
23045                                               if (((word >> 30) & 0x1) == 0)
23046                                                 {
23047                                                   /* 33222222222211111111110000000000
23048                                                      10987654321098765432109876543210
23049                                                      x0001111xxxxxxxx1010x0xxxxxxxxxx
23050                                                      smull.  */
23051                                                   return 107;
23052                                                 }
23053                                               else
23054                                                 {
23055                                                   /* 33222222222211111111110000000000
23056                                                      10987654321098765432109876543210
23057                                                      x1001111xxxxxxxx1010x0xxxxxxxxxx
23058                                                      smull2.  */
23059                                                   return 108;
23060                                                 }
23061                                             }
23062                                           else
23063                                             {
23064                                               if (((word >> 30) & 0x1) == 0)
23065                                                 {
23066                                                   /* 33222222222211111111110000000000
23067                                                      10987654321098765432109876543210
23068                                                      x0101111xxxxxxxx1010x0xxxxxxxxxx
23069                                                      umull.  */
23070                                                   return 125;
23071                                                 }
23072                                               else
23073                                                 {
23074                                                   /* 33222222222211111111110000000000
23075                                                      10987654321098765432109876543210
23076                                                      x1101111xxxxxxxx1010x0xxxxxxxxxx
23077                                                      umull2.  */
23078                                                   return 126;
23079                                                 }
23080                                             }
23081                                         }
23082                                       else
23083                                         {
23084                                           if (((word >> 29) & 0x1) == 0)
23085                                             {
23086                                               /* 33222222222211111111110000000000
23087                                                  10987654321098765432109876543210
23088                                                  xx001111xxxxxxxx1110x0xxxxxxxxxx
23089                                                  sdot.  */
23090                                               return 2414;
23091                                             }
23092                                           else
23093                                             {
23094                                               /* 33222222222211111111110000000000
23095                                                  10987654321098765432109876543210
23096                                                  xx101111xxxxxxxx1110x0xxxxxxxxxx
23097                                                  udot.  */
23098                                               return 2413;
23099                                             }
23100                                         }
23101                                     }
23102                                 }
23103                               else
23104                                 {
23105                                   if (((word >> 13) & 0x1) == 0)
23106                                     {
23107                                       if (((word >> 14) & 0x1) == 0)
23108                                         {
23109                                           if (((word >> 23) & 0x1) == 0)
23110                                             {
23111                                               if (((word >> 29) & 0x1) == 0)
23112                                                 {
23113                                                   /* 33222222222211111111110000000000
23114                                                      10987654321098765432109876543210
23115                                                      xx0011110xxxxxxx1001x0xxxxxxxxxx
23116                                                      fmul.  */
23117                                                   return 118;
23118                                                 }
23119                                               else
23120                                                 {
23121                                                   /* 33222222222211111111110000000000
23122                                                      10987654321098765432109876543210
23123                                                      xx1011110xxxxxxx1001x0xxxxxxxxxx
23124                                                      fmulx.  */
23125                                                   return 128;
23126                                                 }
23127                                             }
23128                                           else
23129                                             {
23130                                               if (((word >> 29) & 0x1) == 0)
23131                                                 {
23132                                                   /* 33222222222211111111110000000000
23133                                                      10987654321098765432109876543210
23134                                                      xx0011111xxxxxxx1001x0xxxxxxxxxx
23135                                                      fmul.  */
23136                                                   return 117;
23137                                                 }
23138                                               else
23139                                                 {
23140                                                   /* 33222222222211111111110000000000
23141                                                      10987654321098765432109876543210
23142                                                      xx1011111xxxxxxx1001x0xxxxxxxxxx
23143                                                      fmulx.  */
23144                                                   return 127;
23145                                                 }
23146                                             }
23147                                         }
23148                                       else
23149                                         {
23150                                           if (((word >> 29) & 0x1) == 0)
23151                                             {
23152                                               /* 33222222222211111111110000000000
23153                                                  10987654321098765432109876543210
23154                                                  xx001111xxxxxxxx1101x0xxxxxxxxxx
23155                                                  sqrdmulh.  */
23156                                               return 112;
23157                                             }
23158                                           else
23159                                             {
23160                                               /* 33222222222211111111110000000000
23161                                                  10987654321098765432109876543210
23162                                                  xx101111xxxxxxxx1101x0xxxxxxxxxx
23163                                                  sqrdmlah.  */
23164                                               return 129;
23165                                             }
23166                                         }
23167                                     }
23168                                   else
23169                                     {
23170                                       if (((word >> 14) & 0x1) == 0)
23171                                         {
23172                                           if (((word >> 30) & 0x1) == 0)
23173                                             {
23174                                               /* 33222222222211111111110000000000
23175                                                  10987654321098765432109876543210
23176                                                  x0x01111xxxxxxxx1011x0xxxxxxxxxx
23177                                                  sqdmull.  */
23178                                               return 109;
23179                                             }
23180                                           else
23181                                             {
23182                                               /* 33222222222211111111110000000000
23183                                                  10987654321098765432109876543210
23184                                                  x1x01111xxxxxxxx1011x0xxxxxxxxxx
23185                                                  sqdmull2.  */
23186                                               return 110;
23187                                             }
23188                                         }
23189                                       else
23190                                         {
23191                                           if (((word >> 29) & 0x1) == 0)
23192                                             {
23193                                               if (((word >> 22) & 0x1) == 0)
23194                                                 {
23195                                                   if (((word >> 23) & 0x1) == 0)
23196                                                     {
23197                                                       /* 33222222222211111111110000000000
23198                                                          10987654321098765432109876543210
23199                                                          xx00111100xxxxxx1111x0xxxxxxxxxx
23200                                                          sudot.  */
23201                                                       return 2491;
23202                                                     }
23203                                                   else
23204                                                     {
23205                                                       /* 33222222222211111111110000000000
23206                                                          10987654321098765432109876543210
23207                                                          xx00111110xxxxxx1111x0xxxxxxxxxx
23208                                                          usdot.  */
23209                                                       return 2490;
23210                                                     }
23211                                                 }
23212                                               else
23213                                                 {
23214                                                   if (((word >> 23) & 0x1) == 0)
23215                                                     {
23216                                                       /* 33222222222211111111110000000000
23217                                                          10987654321098765432109876543210
23218                                                          xx00111101xxxxxx1111x0xxxxxxxxxx
23219                                                          bfdot.  */
23220                                                       return 2502;
23221                                                     }
23222                                                   else
23223                                                     {
23224                                                       if (((word >> 30) & 0x1) == 0)
23225                                                         {
23226                                                           /* 33222222222211111111110000000000
23227                                                              10987654321098765432109876543210
23228                                                              x000111111xxxxxx1111x0xxxxxxxxxx
23229                                                              bfmlalb.  */
23230                                                           return 2510;
23231                                                         }
23232                                                       else
23233                                                         {
23234                                                           /* 33222222222211111111110000000000
23235                                                              10987654321098765432109876543210
23236                                                              x100111111xxxxxx1111x0xxxxxxxxxx
23237                                                              bfmlalt.  */
23238                                                           return 2509;
23239                                                         }
23240                                                     }
23241                                                 }
23242                                             }
23243                                           else
23244                                             {
23245                                               /* 33222222222211111111110000000000
23246                                                  10987654321098765432109876543210
23247                                                  xx101111xxxxxxxx1111x0xxxxxxxxxx
23248                                                  sqrdmlsh.  */
23249                                               return 130;
23250                                             }
23251                                         }
23252                                     }
23253                                 }
23254                             }
23255                           else
23256                             {
23257                               if (((word >> 11) & 0x1) == 0)
23258                                 {
23259                                   if (((word >> 14) & 0x1) == 0)
23260                                     {
23261                                       if (((word >> 12) & 0x1) == 0)
23262                                         {
23263                                           if (((word >> 29) & 0x1) == 0)
23264                                             {
23265                                               /* 33222222222211111111110000000000
23266                                                  10987654321098765432109876543210
23267                                                  xx001111xxxxxxxx10x001xxxxxxxxxx
23268                                                  movi.  */
23269                                               return 135;
23270                                             }
23271                                           else
23272                                             {
23273                                               /* 33222222222211111111110000000000
23274                                                  10987654321098765432109876543210
23275                                                  xx101111xxxxxxxx10x001xxxxxxxxxx
23276                                                  mvni.  */
23277                                               return 143;
23278                                             }
23279                                         }
23280                                       else
23281                                         {
23282                                           if (((word >> 29) & 0x1) == 0)
23283                                             {
23284                                               /* 33222222222211111111110000000000
23285                                                  10987654321098765432109876543210
23286                                                  xx001111xxxxxxxx10x101xxxxxxxxxx
23287                                                  orr.  */
23288                                               return 136;
23289                                             }
23290                                           else
23291                                             {
23292                                               /* 33222222222211111111110000000000
23293                                                  10987654321098765432109876543210
23294                                                  xx101111xxxxxxxx10x101xxxxxxxxxx
23295                                                  bic.  */
23296                                               return 144;
23297                                             }
23298                                         }
23299                                     }
23300                                   else
23301                                     {
23302                                       if (((word >> 13) & 0x1) == 0)
23303                                         {
23304                                           if (((word >> 29) & 0x1) == 0)
23305                                             {
23306                                               /* 33222222222211111111110000000000
23307                                                  10987654321098765432109876543210
23308                                                  xx001111xxxxxxxx110x01xxxxxxxxxx
23309                                                  movi.  */
23310                                               return 137;
23311                                             }
23312                                           else
23313                                             {
23314                                               /* 33222222222211111111110000000000
23315                                                  10987654321098765432109876543210
23316                                                  xx101111xxxxxxxx110x01xxxxxxxxxx
23317                                                  mvni.  */
23318                                               return 145;
23319                                             }
23320                                         }
23321                                       else
23322                                         {
23323                                           if (((word >> 12) & 0x1) == 0)
23324                                             {
23325                                               if (((word >> 29) & 0x1) == 0)
23326                                                 {
23327                                                   /* 33222222222211111111110000000000
23328                                                      10987654321098765432109876543210
23329                                                      xx001111xxxxxxxx111001xxxxxxxxxx
23330                                                      movi.  */
23331                                                   return 138;
23332                                                 }
23333                                               else
23334                                                 {
23335                                                   /* 33222222222211111111110000000000
23336                                                      10987654321098765432109876543210
23337                                                      xx101111xxxxxxxx111001xxxxxxxxxx
23338                                                      movi.  */
23339                                                   return 146;
23340                                                 }
23341                                             }
23342                                           else
23343                                             {
23344                                               if (((word >> 29) & 0x1) == 0)
23345                                                 {
23346                                                   /* 33222222222211111111110000000000
23347                                                      10987654321098765432109876543210
23348                                                      xx001111xxxxxxxx111101xxxxxxxxxx
23349                                                      fmov.  */
23350                                                   return 139;
23351                                                 }
23352                                               else
23353                                                 {
23354                                                   /* 33222222222211111111110000000000
23355                                                      10987654321098765432109876543210
23356                                                      xx101111xxxxxxxx111101xxxxxxxxxx
23357                                                      fmov.  */
23358                                                   return 148;
23359                                                 }
23360                                             }
23361                                         }
23362                                     }
23363                                 }
23364                               else
23365                                 {
23366                                   if (((word >> 12) & 0x1) == 0)
23367                                     {
23368                                       if (((word >> 29) & 0x1) == 0)
23369                                         {
23370                                           if (((word >> 30) & 0x1) == 0)
23371                                             {
23372                                               /* 33222222222211111111110000000000
23373                                                  10987654321098765432109876543210
23374                                                  x0001111xxxxxxxx1xx011xxxxxxxxxx
23375                                                  rshrn.  */
23376                                               return 382;
23377                                             }
23378                                           else
23379                                             {
23380                                               /* 33222222222211111111110000000000
23381                                                  10987654321098765432109876543210
23382                                                  x1001111xxxxxxxx1xx011xxxxxxxxxx
23383                                                  rshrn2.  */
23384                                               return 383;
23385                                             }
23386                                         }
23387                                       else
23388                                         {
23389                                           if (((word >> 30) & 0x1) == 0)
23390                                             {
23391                                               /* 33222222222211111111110000000000
23392                                                  10987654321098765432109876543210
23393                                                  x0101111xxxxxxxx1xx011xxxxxxxxxx
23394                                                  sqrshrun.  */
23395                                               return 406;
23396                                             }
23397                                           else
23398                                             {
23399                                               /* 33222222222211111111110000000000
23400                                                  10987654321098765432109876543210
23401                                                  x1101111xxxxxxxx1xx011xxxxxxxxxx
23402                                                  sqrshrun2.  */
23403                                               return 407;
23404                                             }
23405                                         }
23406                                     }
23407                                   else
23408                                     {
23409                                       if (((word >> 13) & 0x1) == 0)
23410                                         {
23411                                           if (((word >> 29) & 0x1) == 0)
23412                                             {
23413                                               if (((word >> 30) & 0x1) == 0)
23414                                                 {
23415                                                   /* 33222222222211111111110000000000
23416                                                      10987654321098765432109876543210
23417                                                      x0001111xxxxxxxx1x0111xxxxxxxxxx
23418                                                      sqrshrn.  */
23419                                                   return 386;
23420                                                 }
23421                                               else
23422                                                 {
23423                                                   /* 33222222222211111111110000000000
23424                                                      10987654321098765432109876543210
23425                                                      x1001111xxxxxxxx1x0111xxxxxxxxxx
23426                                                      sqrshrn2.  */
23427                                                   return 387;
23428                                                 }
23429                                             }
23430                                           else
23431                                             {
23432                                               if (((word >> 30) & 0x1) == 0)
23433                                                 {
23434                                                   /* 33222222222211111111110000000000
23435                                                      10987654321098765432109876543210
23436                                                      x0101111xxxxxxxx1x0111xxxxxxxxxx
23437                                                      uqrshrn.  */
23438                                                   return 410;
23439                                                 }
23440                                               else
23441                                                 {
23442                                                   /* 33222222222211111111110000000000
23443                                                      10987654321098765432109876543210
23444                                                      x1101111xxxxxxxx1x0111xxxxxxxxxx
23445                                                      uqrshrn2.  */
23446                                                   return 411;
23447                                                 }
23448                                             }
23449                                         }
23450                                       else
23451                                         {
23452                                           if (((word >> 29) & 0x1) == 0)
23453                                             {
23454                                               /* 33222222222211111111110000000000
23455                                                  10987654321098765432109876543210
23456                                                  xx001111xxxxxxxx1x1111xxxxxxxxxx
23457                                                  fmov.  */
23458                                               return 140;
23459                                             }
23460                                           else
23461                                             {
23462                                               /* 33222222222211111111110000000000
23463                                                  10987654321098765432109876543210
23464                                                  xx101111xxxxxxxx1x1111xxxxxxxxxx
23465                                                  fcvtzu.  */
23466                                               return 418;
23467                                             }
23468                                         }
23469                                     }
23470                                 }
23471                             }
23472                         }
23473                       else
23474                         {
23475                           if (((word >> 29) & 0x1) == 0)
23476                             {
23477                               if (((word >> 30) & 0x1) == 0)
23478                                 {
23479                                   if (((word >> 21) & 0x1) == 0)
23480                                     {
23481                                       /* 33222222222211111111110000000000
23482                                          10987654321098765432109876543210
23483                                          x0011111xx0xxxxx1xxxxxxxxxxxxxxx
23484                                          fmsub.  */
23485                                       return 860;
23486                                     }
23487                                   else
23488                                     {
23489                                       /* 33222222222211111111110000000000
23490                                          10987654321098765432109876543210
23491                                          x0011111xx1xxxxx1xxxxxxxxxxxxxxx
23492                                          fnmsub.  */
23493                                       return 864;
23494                                     }
23495                                 }
23496                               else
23497                                 {
23498                                   if (((word >> 10) & 0x1) == 0)
23499                                     {
23500                                       if (((word >> 12) & 0x1) == 0)
23501                                         {
23502                                           /* 33222222222211111111110000000000
23503                                              10987654321098765432109876543210
23504                                              x1011111xxxxxxxx1xx0x0xxxxxxxxxx
23505                                              sqdmulh.  */
23506                                           return 428;
23507                                         }
23508                                       else
23509                                         {
23510                                           if (((word >> 13) & 0x1) == 0)
23511                                             {
23512                                               if (((word >> 14) & 0x1) == 0)
23513                                                 {
23514                                                   if (((word >> 23) & 0x1) == 0)
23515                                                     {
23516                                                       /* 33222222222211111111110000000000
23517                                                          10987654321098765432109876543210
23518                                                          x10111110xxxxxxx1001x0xxxxxxxxxx
23519                                                          fmul.  */
23520                                                       return 435;
23521                                                     }
23522                                                   else
23523                                                     {
23524                                                       /* 33222222222211111111110000000000
23525                                                          10987654321098765432109876543210
23526                                                          x10111111xxxxxxx1001x0xxxxxxxxxx
23527                                                          fmul.  */
23528                                                       return 434;
23529                                                     }
23530                                                 }
23531                                               else
23532                                                 {
23533                                                   /* 33222222222211111111110000000000
23534                                                      10987654321098765432109876543210
23535                                                      x1011111xxxxxxxx1101x0xxxxxxxxxx
23536                                                      sqrdmulh.  */
23537                                                   return 429;
23538                                                 }
23539                                             }
23540                                           else
23541                                             {
23542                                               /* 33222222222211111111110000000000
23543                                                  10987654321098765432109876543210
23544                                                  x1011111xxxxxxxx1x11x0xxxxxxxxxx
23545                                                  sqdmull.  */
23546                                               return 427;
23547                                             }
23548                                         }
23549                                     }
23550                                   else
23551                                     {
23552                                       if (((word >> 11) & 0x1) == 0)
23553                                         {
23554                                           if (((word >> 12) & 0x1) == 0)
23555                                             {
23556                                               /* 33222222222211111111110000000000
23557                                                  10987654321098765432109876543210
23558                                                  x1011111xxxxxxxx1xx001xxxxxxxxxx
23559                                                  scvtf.  */
23560                                               return 598;
23561                                             }
23562                                           else
23563                                             {
23564                                               /* 33222222222211111111110000000000
23565                                                  10987654321098765432109876543210
23566                                                  x1011111xxxxxxxx1xx101xxxxxxxxxx
23567                                                  sqshrn.  */
23568                                               return 596;
23569                                             }
23570                                         }
23571                                       else
23572                                         {
23573                                           if (((word >> 13) & 0x1) == 0)
23574                                             {
23575                                               /* 33222222222211111111110000000000
23576                                                  10987654321098765432109876543210
23577                                                  x1011111xxxxxxxx1x0x11xxxxxxxxxx
23578                                                  sqrshrn.  */
23579                                               return 597;
23580                                             }
23581                                           else
23582                                             {
23583                                               /* 33222222222211111111110000000000
23584                                                  10987654321098765432109876543210
23585                                                  x1011111xxxxxxxx1x1x11xxxxxxxxxx
23586                                                  fcvtzs.  */
23587                                               return 600;
23588                                             }
23589                                         }
23590                                     }
23591                                 }
23592                             }
23593                           else
23594                             {
23595                               if (((word >> 10) & 0x1) == 0)
23596                                 {
23597                                   if (((word >> 13) & 0x1) == 0)
23598                                     {
23599                                       if (((word >> 14) & 0x1) == 0)
23600                                         {
23601                                           if (((word >> 23) & 0x1) == 0)
23602                                             {
23603                                               /* 33222222222211111111110000000000
23604                                                  10987654321098765432109876543210
23605                                                  xx1111110xxxxxxx100xx0xxxxxxxxxx
23606                                                  fmulx.  */
23607                                               return 437;
23608                                             }
23609                                           else
23610                                             {
23611                                               /* 33222222222211111111110000000000
23612                                                  10987654321098765432109876543210
23613                                                  xx1111111xxxxxxx100xx0xxxxxxxxxx
23614                                                  fmulx.  */
23615                                               return 436;
23616                                             }
23617                                         }
23618                                       else
23619                                         {
23620                                           /* 33222222222211111111110000000000
23621                                              10987654321098765432109876543210
23622                                              xx111111xxxxxxxx110xx0xxxxxxxxxx
23623                                              sqrdmlah.  */
23624                                           return 438;
23625                                         }
23626                                     }
23627                                   else
23628                                     {
23629                                       /* 33222222222211111111110000000000
23630                                          10987654321098765432109876543210
23631                                          xx111111xxxxxxxx1x1xx0xxxxxxxxxx
23632                                          sqrdmlsh.  */
23633                                       return 439;
23634                                     }
23635                                 }
23636                               else
23637                                 {
23638                                   if (((word >> 11) & 0x1) == 0)
23639                                     {
23640                                       if (((word >> 12) & 0x1) == 0)
23641                                         {
23642                                           if (((word >> 13) & 0x1) == 0)
23643                                             {
23644                                               /* 33222222222211111111110000000000
23645                                                  10987654321098765432109876543210
23646                                                  xx111111xxxxxxxx1x0001xxxxxxxxxx
23647                                                  sqshrun.  */
23648                                               return 610;
23649                                             }
23650                                           else
23651                                             {
23652                                               /* 33222222222211111111110000000000
23653                                                  10987654321098765432109876543210
23654                                                  xx111111xxxxxxxx1x1001xxxxxxxxxx
23655                                                  ucvtf.  */
23656                                               return 614;
23657                                             }
23658                                         }
23659                                       else
23660                                         {
23661                                           /* 33222222222211111111110000000000
23662                                              10987654321098765432109876543210
23663                                              xx111111xxxxxxxx1xx101xxxxxxxxxx
23664                                              uqshrn.  */
23665                                           return 612;
23666                                         }
23667                                     }
23668                                   else
23669                                     {
23670                                       if (((word >> 12) & 0x1) == 0)
23671                                         {
23672                                           /* 33222222222211111111110000000000
23673                                              10987654321098765432109876543210
23674                                              xx111111xxxxxxxx1xx011xxxxxxxxxx
23675                                              sqrshrun.  */
23676                                           return 611;
23677                                         }
23678                                       else
23679                                         {
23680                                           if (((word >> 13) & 0x1) == 0)
23681                                             {
23682                                               /* 33222222222211111111110000000000
23683                                                  10987654321098765432109876543210
23684                                                  xx111111xxxxxxxx1x0111xxxxxxxxxx
23685                                                  uqrshrn.  */
23686                                               return 613;
23687                                             }
23688                                           else
23689                                             {
23690                                               /* 33222222222211111111110000000000
23691                                                  10987654321098765432109876543210
23692                                                  xx111111xxxxxxxx1x1111xxxxxxxxxx
23693                                                  fcvtzu.  */
23694                                               return 616;
23695                                             }
23696                                         }
23697                                     }
23698                                 }
23699                             }
23700                         }
23701                     }
23702                 }
23703             }
23704         }
23705     }
23706 }
23707
23708 /* Lookup opcode WORD in the opcode table.  N.B. all alias
23709    opcodes are ignored here.  */
23710
23711 const aarch64_opcode *
23712 aarch64_opcode_lookup (uint32_t word)
23713 {
23714   return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);
23715 }
23716
23717 const aarch64_opcode *
23718 aarch64_find_next_opcode (const aarch64_opcode *opcode)
23719 {
23720   /* Use the index as the key to locate the next opcode.  */
23721   int key = opcode - aarch64_opcode_table;
23722   int value;
23723   switch (key)
23724     {
23725     case 2381: value = 2383; break;     /* mov --> mova.  */
23726     case 2383: return NULL;             /* mova --> NULL.  */
23727     case 2380: value = 2382; break;     /* mov --> mova.  */
23728     case 2382: return NULL;             /* mova --> NULL.  */
23729     case 2385: value = 2390; break;     /* ld1b --> ld1b.  */
23730     case 2390: return NULL;             /* ld1b --> NULL.  */
23731     case 2387: value = 2392; break;     /* ld1w --> ld1w.  */
23732     case 2392: return NULL;             /* ld1w --> NULL.  */
23733     case 2386: value = 2391; break;     /* ld1h --> ld1h.  */
23734     case 2391: return NULL;             /* ld1h --> NULL.  */
23735     case 2388: value = 2393; break;     /* ld1d --> ld1d.  */
23736     case 2393: return NULL;             /* ld1d --> NULL.  */
23737     case 2395: value = 2400; break;     /* st1b --> st1b.  */
23738     case 2400: return NULL;             /* st1b --> NULL.  */
23739     case 2397: value = 2402; break;     /* st1w --> st1w.  */
23740     case 2402: return NULL;             /* st1w --> NULL.  */
23741     case 2396: value = 2401; break;     /* st1h --> st1h.  */
23742     case 2401: return NULL;             /* st1h --> NULL.  */
23743     case 2398: value = 2403; break;     /* st1d --> st1d.  */
23744     case 2403: return NULL;             /* st1d --> NULL.  */
23745     case 2389: value = 2394; break;     /* ld1q --> ld1q.  */
23746     case 2394: return NULL;             /* ld1q --> NULL.  */
23747     case 2399: value = 2404; break;     /* st1q --> st1q.  */
23748     case 2404: return NULL;             /* st1q --> NULL.  */
23749     case 12: value = 19; break; /* add --> addg.  */
23750     case 19: return NULL;               /* addg --> NULL.  */
23751     case 16: value = 20; break; /* sub --> subg.  */
23752     case 20: return NULL;               /* subg --> NULL.  */
23753     case 971: value = 975; break;       /* stnp --> stp.  */
23754     case 975: return NULL;              /* stp --> NULL.  */
23755     case 969: value = 970; break;       /* stllrb --> stllrh.  */
23756     case 970: return NULL;              /* stllrh --> NULL.  */
23757     case 972: value = 976; break;       /* ldnp --> ldp.  */
23758     case 976: return NULL;              /* ldp --> NULL.  */
23759     case 1640: value = 1641; break;     /* ldff1b --> ldff1b.  */
23760     case 1641: return NULL;             /* ldff1b --> NULL.  */
23761     case 1696: value = 1697; break;     /* ldff1sw --> ldff1sw.  */
23762     case 1697: return NULL;             /* ldff1sw --> NULL.  */
23763     case 1644: value = 1645; break;     /* ldff1b --> ldff1b.  */
23764     case 1645: return NULL;             /* ldff1b --> NULL.  */
23765     case 1663: value = 1664; break;     /* ldff1h --> ldff1h.  */
23766     case 1664: return NULL;             /* ldff1h --> NULL.  */
23767     case 1642: value = 1643; break;     /* ldff1b --> ldff1b.  */
23768     case 1643: return NULL;             /* ldff1b --> NULL.  */
23769     case 1661: value = 1662; break;     /* ldff1h --> ldff1h.  */
23770     case 1662: return NULL;             /* ldff1h --> NULL.  */
23771     case 1646: value = 1647; break;     /* ldff1b --> ldff1b.  */
23772     case 1647: return NULL;             /* ldff1b --> NULL.  */
23773     case 1665: value = 1666; break;     /* ldff1h --> ldff1h.  */
23774     case 1666: return NULL;             /* ldff1h --> NULL.  */
23775     case 1686: value = 1687; break;     /* ldff1sh --> ldff1sh.  */
23776     case 1687: return NULL;             /* ldff1sh --> NULL.  */
23777     case 1674: value = 1675; break;     /* ldff1sb --> ldff1sb.  */
23778     case 1675: return NULL;             /* ldff1sb --> NULL.  */
23779     case 1705: value = 1706; break;     /* ldff1w --> ldff1w.  */
23780     case 1706: return NULL;             /* ldff1w --> NULL.  */
23781     case 1678: value = 1679; break;     /* ldff1sb --> ldff1sb.  */
23782     case 1679: return NULL;             /* ldff1sb --> NULL.  */
23783     case 1688: value = 1689; break;     /* ldff1sh --> ldff1sh.  */
23784     case 1689: return NULL;             /* ldff1sh --> NULL.  */
23785     case 1676: value = 1677; break;     /* ldff1sb --> ldff1sb.  */
23786     case 1677: return NULL;             /* ldff1sb --> NULL.  */
23787     case 1707: value = 1708; break;     /* ldff1w --> ldff1w.  */
23788     case 1708: return NULL;             /* ldff1w --> NULL.  */
23789     case 1652: value = 1653; break;     /* ldff1d --> ldff1d.  */
23790     case 1653: return NULL;             /* ldff1d --> NULL.  */
23791     case 811: value = 812; break;       /* xaflag --> axflag.  */
23792     case 812: value = 1194; break;      /* axflag --> tcommit.  */
23793     case 1194: value = 1197; break;     /* tcommit --> smstart.  */
23794     case 1197: value = 1198; break;     /* smstart --> smstop.  */
23795     case 1198: value = 1199; break;     /* smstop --> smstart.  */
23796     case 1199: value = 1200; break;     /* smstart --> smstop.  */
23797     case 1200: value = 1201; break;     /* smstop --> msr.  */
23798     case 1201: value = 1202; break;     /* msr --> hint.  */
23799     case 1202: value = 1211; break;     /* hint --> dgh.  */
23800     case 1211: value = 1220; break;     /* dgh --> clrex.  */
23801     case 1220: value = 1221; break;     /* clrex --> dsb.  */
23802     case 1221: value = 1222; break;     /* dsb --> dsb.  */
23803     case 1222: value = 1226; break;     /* dsb --> dmb.  */
23804     case 1226: value = 1227; break;     /* dmb --> isb.  */
23805     case 1227: value = 1228; break;     /* isb --> sb.  */
23806     case 1228: value = 1229; break;     /* sb --> sys.  */
23807     case 1229: value = 1234; break;     /* sys --> wfet.  */
23808     case 1234: value = 1235; break;     /* wfet --> wfit.  */
23809     case 1235: value = 1239; break;     /* wfit --> cfinv.  */
23810     case 1239: value = 1240; break;     /* cfinv --> msr.  */
23811     case 1240: return NULL;             /* msr --> NULL.  */
23812     case 1193: value = 1195; break;     /* tstart --> ttest.  */
23813     case 1195: value = 1241; break;     /* ttest --> sysl.  */
23814     case 1241: value = 1242; break;     /* sysl --> mrs.  */
23815     case 1242: return NULL;             /* mrs --> NULL.  */
23816     case 440: value = 441; break;       /* st4 --> st1.  */
23817     case 441: value = 442; break;       /* st1 --> st2.  */
23818     case 442: value = 443; break;       /* st2 --> st3.  */
23819     case 443: return NULL;              /* st3 --> NULL.  */
23820     case 448: value = 449; break;       /* st4 --> st1.  */
23821     case 449: value = 450; break;       /* st1 --> st2.  */
23822     case 450: value = 451; break;       /* st2 --> st3.  */
23823     case 451: return NULL;              /* st3 --> NULL.  */
23824     case 444: value = 445; break;       /* ld4 --> ld1.  */
23825     case 445: value = 446; break;       /* ld1 --> ld2.  */
23826     case 446: value = 447; break;       /* ld2 --> ld3.  */
23827     case 447: return NULL;              /* ld3 --> NULL.  */
23828     case 460: value = 462; break;       /* ld1 --> ld1r.  */
23829     case 462: return NULL;              /* ld1r --> NULL.  */
23830     case 464: value = 466; break;       /* ld2 --> ld2r.  */
23831     case 466: return NULL;              /* ld2r --> NULL.  */
23832     case 461: value = 463; break;       /* ld3 --> ld3r.  */
23833     case 463: return NULL;              /* ld3r --> NULL.  */
23834     case 465: value = 467; break;       /* ld4 --> ld4r.  */
23835     case 467: return NULL;              /* ld4r --> NULL.  */
23836     case 452: value = 453; break;       /* ld4 --> ld1.  */
23837     case 453: value = 454; break;       /* ld1 --> ld2.  */
23838     case 454: value = 455; break;       /* ld2 --> ld3.  */
23839     case 455: return NULL;              /* ld3 --> NULL.  */
23840     case 472: value = 474; break;       /* ld1 --> ld1r.  */
23841     case 474: return NULL;              /* ld1r --> NULL.  */
23842     case 473: value = 475; break;       /* ld3 --> ld3r.  */
23843     case 475: return NULL;              /* ld3r --> NULL.  */
23844     case 476: value = 478; break;       /* ld2 --> ld2r.  */
23845     case 478: return NULL;              /* ld2r --> NULL.  */
23846     case 477: value = 479; break;       /* ld4 --> ld4r.  */
23847     case 479: return NULL;              /* ld4r --> NULL.  */
23848     case 764: value = 765; break;       /* fcvtzs --> fcvtzs.  */
23849     case 765: return NULL;              /* fcvtzs --> NULL.  */
23850     case 760: value = 761; break;       /* scvtf --> scvtf.  */
23851     case 761: return NULL;              /* scvtf --> NULL.  */
23852     case 766: value = 767; break;       /* fcvtzu --> fcvtzu.  */
23853     case 767: return NULL;              /* fcvtzu --> NULL.  */
23854     case 762: value = 763; break;       /* ucvtf --> ucvtf.  */
23855     case 763: return NULL;              /* ucvtf --> NULL.  */
23856     case 768: value = 769; break;       /* fcvtns --> fcvtns.  */
23857     case 769: return NULL;              /* fcvtns --> NULL.  */
23858     case 788: value = 789; break;       /* fcvtms --> fcvtms.  */
23859     case 789: return NULL;              /* fcvtms --> NULL.  */
23860     case 784: value = 785; break;       /* fcvtps --> fcvtps.  */
23861     case 785: return NULL;              /* fcvtps --> NULL.  */
23862     case 792: value = 793; break;       /* fcvtzs --> fcvtzs.  */
23863     case 793: return NULL;              /* fcvtzs --> NULL.  */
23864     case 776: value = 777; break;       /* fcvtas --> fcvtas.  */
23865     case 777: return NULL;              /* fcvtas --> NULL.  */
23866     case 772: value = 773; break;       /* scvtf --> scvtf.  */
23867     case 773: return NULL;              /* scvtf --> NULL.  */
23868     case 780: value = 781; break;       /* fmov --> fmov.  */
23869     case 781: return NULL;              /* fmov --> NULL.  */
23870     case 770: value = 771; break;       /* fcvtnu --> fcvtnu.  */
23871     case 771: return NULL;              /* fcvtnu --> NULL.  */
23872     case 790: value = 791; break;       /* fcvtmu --> fcvtmu.  */
23873     case 791: return NULL;              /* fcvtmu --> NULL.  */
23874     case 786: value = 787; break;       /* fcvtpu --> fcvtpu.  */
23875     case 787: return NULL;              /* fcvtpu --> NULL.  */
23876     case 794: value = 795; break;       /* fcvtzu --> fcvtzu.  */
23877     case 795: return NULL;              /* fcvtzu --> NULL.  */
23878     case 778: value = 779; break;       /* fcvtau --> fcvtau.  */
23879     case 779: return NULL;              /* fcvtau --> NULL.  */
23880     case 774: value = 775; break;       /* ucvtf --> ucvtf.  */
23881     case 775: return NULL;              /* ucvtf --> NULL.  */
23882     case 782: value = 783; break;       /* fmov --> fmov.  */
23883     case 783: return NULL;              /* fmov --> NULL.  */
23884     case 817: value = 818; break;       /* fmov --> fmov.  */
23885     case 818: return NULL;              /* fmov --> NULL.  */
23886     case 826: value = 827; break;       /* frintn --> frintn.  */
23887     case 827: return NULL;              /* frintn --> NULL.  */
23888     case 821: value = 822; break;       /* fneg --> fneg.  */
23889     case 822: return NULL;              /* fneg --> NULL.  */
23890     case 830: value = 831; break;       /* frintm --> frintm.  */
23891     case 831: return NULL;              /* frintm --> NULL.  */
23892     case 819: value = 820; break;       /* fabs --> fabs.  */
23893     case 820: return NULL;              /* fabs --> NULL.  */
23894     case 828: value = 829; break;       /* frintp --> frintp.  */
23895     case 829: return NULL;              /* frintp --> NULL.  */
23896     case 823: value = 824; break;       /* fsqrt --> fsqrt.  */
23897     case 824: return NULL;              /* fsqrt --> NULL.  */
23898     case 832: value = 833; break;       /* frintz --> frintz.  */
23899     case 833: return NULL;              /* frintz --> NULL.  */
23900     case 825: value = 2506; break;      /* fcvt --> bfcvt.  */
23901     case 2506: return NULL;             /* bfcvt --> NULL.  */
23902     case 834: value = 835; break;       /* frinta --> frinta.  */
23903     case 835: return NULL;              /* frinta --> NULL.  */
23904     case 836: value = 837; break;       /* frintx --> frintx.  */
23905     case 837: return NULL;              /* frintx --> NULL.  */
23906     case 838: value = 839; break;       /* frinti --> frinti.  */
23907     case 839: return NULL;              /* frinti --> NULL.  */
23908     case 803: value = 804; break;       /* fcmp --> fcmp.  */
23909     case 804: return NULL;              /* fcmp --> NULL.  */
23910     case 805: value = 806; break;       /* fcmpe --> fcmpe.  */
23911     case 806: return NULL;              /* fcmpe --> NULL.  */
23912     case 807: value = 808; break;       /* fcmp --> fcmp.  */
23913     case 808: return NULL;              /* fcmp --> NULL.  */
23914     case 809: value = 810; break;       /* fcmpe --> fcmpe.  */
23915     case 810: return NULL;              /* fcmpe --> NULL.  */
23916     case 866: value = 867; break;       /* fmov --> fmov.  */
23917     case 867: return NULL;              /* fmov --> NULL.  */
23918     case 840: value = 841; break;       /* fmul --> fmul.  */
23919     case 841: return NULL;              /* fmul --> NULL.  */
23920     case 856: value = 857; break;       /* fnmul --> fnmul.  */
23921     case 857: return NULL;              /* fnmul --> NULL.  */
23922     case 848: value = 849; break;       /* fmax --> fmax.  */
23923     case 849: return NULL;              /* fmax --> NULL.  */
23924     case 844: value = 845; break;       /* fadd --> fadd.  */
23925     case 845: return NULL;              /* fadd --> NULL.  */
23926     case 852: value = 853; break;       /* fmaxnm --> fmaxnm.  */
23927     case 853: return NULL;              /* fmaxnm --> NULL.  */
23928     case 842: value = 843; break;       /* fdiv --> fdiv.  */
23929     case 843: return NULL;              /* fdiv --> NULL.  */
23930     case 850: value = 851; break;       /* fmin --> fmin.  */
23931     case 851: return NULL;              /* fmin --> NULL.  */
23932     case 846: value = 847; break;       /* fsub --> fsub.  */
23933     case 847: return NULL;              /* fsub --> NULL.  */
23934     case 854: value = 855; break;       /* fminnm --> fminnm.  */
23935     case 855: return NULL;              /* fminnm --> NULL.  */
23936     case 799: value = 800; break;       /* fccmp --> fccmp.  */
23937     case 800: return NULL;              /* fccmp --> NULL.  */
23938     case 801: value = 802; break;       /* fccmpe --> fccmpe.  */
23939     case 802: return NULL;              /* fccmpe --> NULL.  */
23940     case 868: value = 869; break;       /* fcsel --> fcsel.  */
23941     case 869: return NULL;              /* fcsel --> NULL.  */
23942     case 133: value = 374; break;       /* movi --> sshr.  */
23943     case 374: value = 376; break;       /* sshr --> srshr.  */
23944     case 376: return NULL;              /* srshr --> NULL.  */
23945     case 141: value = 396; break;       /* mvni --> ushr.  */
23946     case 396: value = 398; break;       /* ushr --> urshr.  */
23947     case 398: value = 400; break;       /* urshr --> sri.  */
23948     case 400: value = 402; break;       /* sri --> sqshlu.  */
23949     case 402: return NULL;              /* sqshlu --> NULL.  */
23950     case 134: value = 375; break;       /* orr --> ssra.  */
23951     case 375: value = 377; break;       /* ssra --> srsra.  */
23952     case 377: value = 378; break;       /* srsra --> shl.  */
23953     case 378: value = 379; break;       /* shl --> sqshl.  */
23954     case 379: return NULL;              /* sqshl --> NULL.  */
23955     case 142: value = 397; break;       /* bic --> usra.  */
23956     case 397: value = 399; break;       /* usra --> ursra.  */
23957     case 399: value = 401; break;       /* ursra --> sli.  */
23958     case 401: value = 403; break;       /* sli --> uqshl.  */
23959     case 403: return NULL;              /* uqshl --> NULL.  */
23960     case 858: value = 859; break;       /* fmadd --> fmadd.  */
23961     case 859: return NULL;              /* fmadd --> NULL.  */
23962     case 862: value = 863; break;       /* fnmadd --> fnmadd.  */
23963     case 863: return NULL;              /* fnmadd --> NULL.  */
23964     case 135: value = 380; break;       /* movi --> shrn.  */
23965     case 380: value = 381; break;       /* shrn --> shrn2.  */
23966     case 381: value = 388; break;       /* shrn2 --> sshll.  */
23967     case 388: value = 390; break;       /* sshll --> sshll2.  */
23968     case 390: return NULL;              /* sshll2 --> NULL.  */
23969     case 143: value = 404; break;       /* mvni --> sqshrun.  */
23970     case 404: value = 405; break;       /* sqshrun --> sqshrun2.  */
23971     case 405: value = 412; break;       /* sqshrun2 --> ushll.  */
23972     case 412: value = 414; break;       /* ushll --> ushll2.  */
23973     case 414: return NULL;              /* ushll2 --> NULL.  */
23974     case 136: value = 384; break;       /* orr --> sqshrn.  */
23975     case 384: value = 385; break;       /* sqshrn --> sqshrn2.  */
23976     case 385: return NULL;              /* sqshrn2 --> NULL.  */
23977     case 144: value = 408; break;       /* bic --> uqshrn.  */
23978     case 408: value = 409; break;       /* uqshrn --> uqshrn2.  */
23979     case 409: return NULL;              /* uqshrn2 --> NULL.  */
23980     case 138: value = 392; break;       /* movi --> scvtf.  */
23981     case 392: value = 393; break;       /* scvtf --> scvtf.  */
23982     case 393: return NULL;              /* scvtf --> NULL.  */
23983     case 146: value = 147; break;       /* movi --> movi.  */
23984     case 147: value = 416; break;       /* movi --> ucvtf.  */
23985     case 416: value = 417; break;       /* ucvtf --> ucvtf.  */
23986     case 417: return NULL;              /* ucvtf --> NULL.  */
23987     case 140: value = 394; break;       /* fmov --> fcvtzs.  */
23988     case 394: value = 395; break;       /* fcvtzs --> fcvtzs.  */
23989     case 395: return NULL;              /* fcvtzs --> NULL.  */
23990     case 418: value = 419; break;       /* fcvtzu --> fcvtzu.  */
23991     case 419: return NULL;              /* fcvtzu --> NULL.  */
23992     case 860: value = 861; break;       /* fmsub --> fmsub.  */
23993     case 861: return NULL;              /* fmsub --> NULL.  */
23994     case 864: value = 865; break;       /* fnmsub --> fnmsub.  */
23995     case 865: return NULL;              /* fnmsub --> NULL.  */
23996     case 598: value = 599; break;       /* scvtf --> scvtf.  */
23997     case 599: return NULL;              /* scvtf --> NULL.  */
23998     case 600: value = 601; break;       /* fcvtzs --> fcvtzs.  */
23999     case 601: return NULL;              /* fcvtzs --> NULL.  */
24000     case 614: value = 615; break;       /* ucvtf --> ucvtf.  */
24001     case 615: return NULL;              /* ucvtf --> NULL.  */
24002     case 616: value = 617; break;       /* fcvtzu --> fcvtzu.  */
24003     case 617: return NULL;              /* fcvtzu --> NULL.  */
24004     default: return NULL;
24005     }
24006
24007   return aarch64_opcode_table + value;
24008 }
24009
24010 const aarch64_opcode *
24011 aarch64_find_alias_opcode (const aarch64_opcode *opcode)
24012 {
24013   /* Use the index as the key to locate the alias opcode.  */
24014   int key = opcode - aarch64_opcode_table;
24015   int value;
24016   switch (key)
24017     {
24018     case 2: value = 3; break;   /* sbc --> ngc.  */
24019     case 4: value = 5; break;   /* sbcs --> ngcs.  */
24020     case 7: value = 8; break;   /* adds --> cmn.  */
24021     case 10: value = 11; break; /* subs --> cmp.  */
24022     case 12: value = 13; break; /* add --> mov.  */
24023     case 14: value = 15; break; /* adds --> cmn.  */
24024     case 17: value = 18; break; /* subs --> cmp.  */
24025     case 22: value = 23; break; /* adds --> cmn.  */
24026     case 24: value = 25; break; /* sub --> neg.  */
24027     case 26: value = 27; break; /* subs --> cmp.  */
24028     case 152: value = 153; break;       /* umov --> mov.  */
24029     case 154: value = 155; break;       /* ins --> mov.  */
24030     case 156: value = 157; break;       /* ins --> mov.  */
24031     case 242: value = 243; break;       /* not --> mvn.  */
24032     case 317: value = 318; break;       /* orr --> mov.  */
24033     case 388: value = 389; break;       /* sshll --> sxtl.  */
24034     case 390: value = 391; break;       /* sshll2 --> sxtl2.  */
24035     case 412: value = 413; break;       /* ushll --> uxtl.  */
24036     case 414: value = 415; break;       /* ushll2 --> uxtl2.  */
24037     case 535: value = 536; break;       /* dup --> mov.  */
24038     case 618: value = 623; break;       /* sbfm --> sxtw.  */
24039     case 625: value = 627; break;       /* bfm --> bfc.  */
24040     case 629: value = 633; break;       /* ubfm --> uxth.  */
24041     case 663: value = 665; break;       /* csinc --> cset.  */
24042     case 666: value = 668; break;       /* csinv --> csetm.  */
24043     case 669: value = 670; break;       /* csneg --> cneg.  */
24044     case 688: value = 688; break;       /* rev --> rev.  */
24045     case 713: value = 714; break;       /* lslv --> lsl.  */
24046     case 715: value = 716; break;       /* lsrv --> lsr.  */
24047     case 717: value = 718; break;       /* asrv --> asr.  */
24048     case 719: value = 720; break;       /* rorv --> ror.  */
24049     case 722: value = 723; break;       /* subps --> cmpp.  */
24050     case 735: value = 736; break;       /* madd --> mul.  */
24051     case 737: value = 738; break;       /* msub --> mneg.  */
24052     case 739: value = 740; break;       /* smaddl --> smull.  */
24053     case 741: value = 742; break;       /* smsubl --> smnegl.  */
24054     case 744: value = 745; break;       /* umaddl --> umull.  */
24055     case 746: value = 747; break;       /* umsubl --> umnegl.  */
24056     case 758: value = 759; break;       /* extr --> ror.  */
24057     case 995: value = 996; break;       /* and --> bic.  */
24058     case 997: value = 998; break;       /* orr --> mov.  */
24059     case 1000: value = 1001; break;     /* ands --> tst.  */
24060     case 1004: value = 1006; break;     /* orr --> uxtw.  */
24061     case 1007: value = 1008; break;     /* orn --> mvn.  */
24062     case 1011: value = 1012; break;     /* ands --> tst.  */
24063     case 1042: value = 1138; break;     /* ldaddb --> staddb.  */
24064     case 1043: value = 1139; break;     /* ldaddh --> staddh.  */
24065     case 1044: value = 1140; break;     /* ldadd --> stadd.  */
24066     case 1046: value = 1141; break;     /* ldaddlb --> staddlb.  */
24067     case 1049: value = 1142; break;     /* ldaddlh --> staddlh.  */
24068     case 1052: value = 1143; break;     /* ldaddl --> staddl.  */
24069     case 1054: value = 1144; break;     /* ldclrb --> stclrb.  */
24070     case 1055: value = 1145; break;     /* ldclrh --> stclrh.  */
24071     case 1056: value = 1146; break;     /* ldclr --> stclr.  */
24072     case 1058: value = 1147; break;     /* ldclrlb --> stclrlb.  */
24073     case 1061: value = 1148; break;     /* ldclrlh --> stclrlh.  */
24074     case 1064: value = 1149; break;     /* ldclrl --> stclrl.  */
24075     case 1066: value = 1150; break;     /* ldeorb --> steorb.  */
24076     case 1067: value = 1151; break;     /* ldeorh --> steorh.  */
24077     case 1068: value = 1152; break;     /* ldeor --> steor.  */
24078     case 1070: value = 1153; break;     /* ldeorlb --> steorlb.  */
24079     case 1073: value = 1154; break;     /* ldeorlh --> steorlh.  */
24080     case 1076: value = 1155; break;     /* ldeorl --> steorl.  */
24081     case 1078: value = 1156; break;     /* ldsetb --> stsetb.  */
24082     case 1079: value = 1157; break;     /* ldseth --> stseth.  */
24083     case 1080: value = 1158; break;     /* ldset --> stset.  */
24084     case 1082: value = 1159; break;     /* ldsetlb --> stsetlb.  */
24085     case 1085: value = 1160; break;     /* ldsetlh --> stsetlh.  */
24086     case 1088: value = 1161; break;     /* ldsetl --> stsetl.  */
24087     case 1090: value = 1162; break;     /* ldsmaxb --> stsmaxb.  */
24088     case 1091: value = 1163; break;     /* ldsmaxh --> stsmaxh.  */
24089     case 1092: value = 1164; break;     /* ldsmax --> stsmax.  */
24090     case 1094: value = 1165; break;     /* ldsmaxlb --> stsmaxlb.  */
24091     case 1097: value = 1166; break;     /* ldsmaxlh --> stsmaxlh.  */
24092     case 1100: value = 1167; break;     /* ldsmaxl --> stsmaxl.  */
24093     case 1102: value = 1168; break;     /* ldsminb --> stsminb.  */
24094     case 1103: value = 1169; break;     /* ldsminh --> stsminh.  */
24095     case 1104: value = 1170; break;     /* ldsmin --> stsmin.  */
24096     case 1106: value = 1171; break;     /* ldsminlb --> stsminlb.  */
24097     case 1109: value = 1172; break;     /* ldsminlh --> stsminlh.  */
24098     case 1112: value = 1173; break;     /* ldsminl --> stsminl.  */
24099     case 1114: value = 1174; break;     /* ldumaxb --> stumaxb.  */
24100     case 1115: value = 1175; break;     /* ldumaxh --> stumaxh.  */
24101     case 1116: value = 1176; break;     /* ldumax --> stumax.  */
24102     case 1118: value = 1177; break;     /* ldumaxlb --> stumaxlb.  */
24103     case 1121: value = 1178; break;     /* ldumaxlh --> stumaxlh.  */
24104     case 1124: value = 1179; break;     /* ldumaxl --> stumaxl.  */
24105     case 1126: value = 1180; break;     /* lduminb --> stuminb.  */
24106     case 1127: value = 1181; break;     /* lduminh --> stuminh.  */
24107     case 1128: value = 1182; break;     /* ldumin --> stumin.  */
24108     case 1130: value = 1183; break;     /* lduminlb --> stuminlb.  */
24109     case 1133: value = 1184; break;     /* lduminlh --> stuminlh.  */
24110     case 1136: value = 1185; break;     /* lduminl --> stuminl.  */
24111     case 1186: value = 1187; break;     /* movn --> mov.  */
24112     case 1188: value = 1189; break;     /* movz --> mov.  */
24113     case 1202: value = 1250; break;     /* hint --> autibsp.  */
24114     case 1221: value = 1225; break;     /* dsb --> pssbb.  */
24115     case 1222: value = 1222; break;     /* dsb --> dsb.  */
24116     case 1229: value = 1238; break;     /* sys --> cpp.  */
24117     case 1234: value = 1234; break;     /* wfet --> wfet.  */
24118     case 1235: value = 1235; break;     /* wfit --> wfit.  */
24119     case 1298: value = 2048; break;     /* and --> bic.  */
24120     case 1300: value = 1281; break;     /* and --> mov.  */
24121     case 1301: value = 1285; break;     /* ands --> movs.  */
24122     case 1336: value = 2049; break;     /* cmpge --> cmple.  */
24123     case 1339: value = 2052; break;     /* cmpgt --> cmplt.  */
24124     case 1341: value = 2050; break;     /* cmphi --> cmplo.  */
24125     case 1344: value = 2051; break;     /* cmphs --> cmpls.  */
24126     case 1366: value = 1278; break;     /* cpy --> mov.  */
24127     case 1367: value = 1280; break;     /* cpy --> mov.  */
24128     case 1368: value = 2059; break;     /* cpy --> fmov.  */
24129     case 1380: value = 1273; break;     /* dup --> mov.  */
24130     case 1381: value = 1275; break;     /* dup --> mov.  */
24131     case 1382: value = 2058; break;     /* dup --> fmov.  */
24132     case 1383: value = 1276; break;     /* dupm --> mov.  */
24133     case 1385: value = 2053; break;     /* eor --> eon.  */
24134     case 1387: value = 1286; break;     /* eor --> not.  */
24135     case 1388: value = 1287; break;     /* eors --> nots.  */
24136     case 1393: value = 2054; break;     /* facge --> facle.  */
24137     case 1394: value = 2055; break;     /* facgt --> faclt.  */
24138     case 1407: value = 2056; break;     /* fcmge --> fcmle.  */
24139     case 1409: value = 2057; break;     /* fcmgt --> fcmlt.  */
24140     case 1415: value = 1270; break;     /* fcpy --> fmov.  */
24141     case 1438: value = 1269; break;     /* fdup --> fmov.  */
24142     case 1769: value = 1271; break;     /* orr --> mov.  */
24143     case 1770: value = 2060; break;     /* orr --> orn.  */
24144     case 1772: value = 1274; break;     /* orr --> mov.  */
24145     case 1773: value = 1284; break;     /* orrs --> movs.  */
24146     case 1835: value = 1279; break;     /* sel --> mov.  */
24147     case 1836: value = 1282; break;     /* sel --> mov.  */
24148     default: return NULL;
24149     }
24150
24151   return aarch64_opcode_table + value;
24152 }
24153
24154 const aarch64_opcode *
24155 aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)
24156 {
24157   /* Use the index as the key to locate the next opcode.  */
24158   int key = opcode - aarch64_opcode_table;
24159   int value;
24160   switch (key)
24161     {
24162     case 3: value = 2; break;   /* ngc --> sbc.  */
24163     case 5: value = 4; break;   /* ngcs --> sbcs.  */
24164     case 8: value = 7; break;   /* cmn --> adds.  */
24165     case 11: value = 10; break; /* cmp --> subs.  */
24166     case 13: value = 12; break; /* mov --> add.  */
24167     case 15: value = 14; break; /* cmn --> adds.  */
24168     case 18: value = 17; break; /* cmp --> subs.  */
24169     case 23: value = 22; break; /* cmn --> adds.  */
24170     case 25: value = 24; break; /* neg --> sub.  */
24171     case 27: value = 28; break; /* cmp --> negs.  */
24172     case 28: value = 26; break; /* negs --> subs.  */
24173     case 153: value = 152; break;       /* mov --> umov.  */
24174     case 155: value = 154; break;       /* mov --> ins.  */
24175     case 157: value = 156; break;       /* mov --> ins.  */
24176     case 243: value = 242; break;       /* mvn --> not.  */
24177     case 318: value = 317; break;       /* mov --> orr.  */
24178     case 389: value = 388; break;       /* sxtl --> sshll.  */
24179     case 391: value = 390; break;       /* sxtl2 --> sshll2.  */
24180     case 413: value = 412; break;       /* uxtl --> ushll.  */
24181     case 415: value = 414; break;       /* uxtl2 --> ushll2.  */
24182     case 536: value = 535; break;       /* mov --> dup.  */
24183     case 623: value = 622; break;       /* sxtw --> sxth.  */
24184     case 622: value = 621; break;       /* sxth --> sxtb.  */
24185     case 621: value = 624; break;       /* sxtb --> asr.  */
24186     case 624: value = 620; break;       /* asr --> sbfx.  */
24187     case 620: value = 619; break;       /* sbfx --> sbfiz.  */
24188     case 619: value = 618; break;       /* sbfiz --> sbfm.  */
24189     case 627: value = 628; break;       /* bfc --> bfxil.  */
24190     case 628: value = 626; break;       /* bfxil --> bfi.  */
24191     case 626: value = 625; break;       /* bfi --> bfm.  */
24192     case 633: value = 632; break;       /* uxth --> uxtb.  */
24193     case 632: value = 635; break;       /* uxtb --> lsr.  */
24194     case 635: value = 634; break;       /* lsr --> lsl.  */
24195     case 634: value = 631; break;       /* lsl --> ubfx.  */
24196     case 631: value = 630; break;       /* ubfx --> ubfiz.  */
24197     case 630: value = 629; break;       /* ubfiz --> ubfm.  */
24198     case 665: value = 664; break;       /* cset --> cinc.  */
24199     case 664: value = 663; break;       /* cinc --> csinc.  */
24200     case 668: value = 667; break;       /* csetm --> cinv.  */
24201     case 667: value = 666; break;       /* cinv --> csinv.  */
24202     case 670: value = 669; break;       /* cneg --> csneg.  */
24203     case 688: value = 689; break;       /* rev --> rev64.  */
24204     case 714: value = 713; break;       /* lsl --> lslv.  */
24205     case 716: value = 715; break;       /* lsr --> lsrv.  */
24206     case 718: value = 717; break;       /* asr --> asrv.  */
24207     case 720: value = 719; break;       /* ror --> rorv.  */
24208     case 723: value = 722; break;       /* cmpp --> subps.  */
24209     case 736: value = 735; break;       /* mul --> madd.  */
24210     case 738: value = 737; break;       /* mneg --> msub.  */
24211     case 740: value = 739; break;       /* smull --> smaddl.  */
24212     case 742: value = 741; break;       /* smnegl --> smsubl.  */
24213     case 745: value = 744; break;       /* umull --> umaddl.  */
24214     case 747: value = 746; break;       /* umnegl --> umsubl.  */
24215     case 759: value = 758; break;       /* ror --> extr.  */
24216     case 996: value = 995; break;       /* bic --> and.  */
24217     case 998: value = 997; break;       /* mov --> orr.  */
24218     case 1001: value = 1000; break;     /* tst --> ands.  */
24219     case 1006: value = 1005; break;     /* uxtw --> mov.  */
24220     case 1005: value = 1004; break;     /* mov --> orr.  */
24221     case 1008: value = 1007; break;     /* mvn --> orn.  */
24222     case 1012: value = 1011; break;     /* tst --> ands.  */
24223     case 1138: value = 1042; break;     /* staddb --> ldaddb.  */
24224     case 1139: value = 1043; break;     /* staddh --> ldaddh.  */
24225     case 1140: value = 1044; break;     /* stadd --> ldadd.  */
24226     case 1141: value = 1046; break;     /* staddlb --> ldaddlb.  */
24227     case 1142: value = 1049; break;     /* staddlh --> ldaddlh.  */
24228     case 1143: value = 1052; break;     /* staddl --> ldaddl.  */
24229     case 1144: value = 1054; break;     /* stclrb --> ldclrb.  */
24230     case 1145: value = 1055; break;     /* stclrh --> ldclrh.  */
24231     case 1146: value = 1056; break;     /* stclr --> ldclr.  */
24232     case 1147: value = 1058; break;     /* stclrlb --> ldclrlb.  */
24233     case 1148: value = 1061; break;     /* stclrlh --> ldclrlh.  */
24234     case 1149: value = 1064; break;     /* stclrl --> ldclrl.  */
24235     case 1150: value = 1066; break;     /* steorb --> ldeorb.  */
24236     case 1151: value = 1067; break;     /* steorh --> ldeorh.  */
24237     case 1152: value = 1068; break;     /* steor --> ldeor.  */
24238     case 1153: value = 1070; break;     /* steorlb --> ldeorlb.  */
24239     case 1154: value = 1073; break;     /* steorlh --> ldeorlh.  */
24240     case 1155: value = 1076; break;     /* steorl --> ldeorl.  */
24241     case 1156: value = 1078; break;     /* stsetb --> ldsetb.  */
24242     case 1157: value = 1079; break;     /* stseth --> ldseth.  */
24243     case 1158: value = 1080; break;     /* stset --> ldset.  */
24244     case 1159: value = 1082; break;     /* stsetlb --> ldsetlb.  */
24245     case 1160: value = 1085; break;     /* stsetlh --> ldsetlh.  */
24246     case 1161: value = 1088; break;     /* stsetl --> ldsetl.  */
24247     case 1162: value = 1090; break;     /* stsmaxb --> ldsmaxb.  */
24248     case 1163: value = 1091; break;     /* stsmaxh --> ldsmaxh.  */
24249     case 1164: value = 1092; break;     /* stsmax --> ldsmax.  */
24250     case 1165: value = 1094; break;     /* stsmaxlb --> ldsmaxlb.  */
24251     case 1166: value = 1097; break;     /* stsmaxlh --> ldsmaxlh.  */
24252     case 1167: value = 1100; break;     /* stsmaxl --> ldsmaxl.  */
24253     case 1168: value = 1102; break;     /* stsminb --> ldsminb.  */
24254     case 1169: value = 1103; break;     /* stsminh --> ldsminh.  */
24255     case 1170: value = 1104; break;     /* stsmin --> ldsmin.  */
24256     case 1171: value = 1106; break;     /* stsminlb --> ldsminlb.  */
24257     case 1172: value = 1109; break;     /* stsminlh --> ldsminlh.  */
24258     case 1173: value = 1112; break;     /* stsminl --> ldsminl.  */
24259     case 1174: value = 1114; break;     /* stumaxb --> ldumaxb.  */
24260     case 1175: value = 1115; break;     /* stumaxh --> ldumaxh.  */
24261     case 1176: value = 1116; break;     /* stumax --> ldumax.  */
24262     case 1177: value = 1118; break;     /* stumaxlb --> ldumaxlb.  */
24263     case 1178: value = 1121; break;     /* stumaxlh --> ldumaxlh.  */
24264     case 1179: value = 1124; break;     /* stumaxl --> ldumaxl.  */
24265     case 1180: value = 1126; break;     /* stuminb --> lduminb.  */
24266     case 1181: value = 1127; break;     /* stuminh --> lduminh.  */
24267     case 1182: value = 1128; break;     /* stumin --> ldumin.  */
24268     case 1183: value = 1130; break;     /* stuminlb --> lduminlb.  */
24269     case 1184: value = 1133; break;     /* stuminlh --> lduminlh.  */
24270     case 1185: value = 1136; break;     /* stuminl --> lduminl.  */
24271     case 1187: value = 1186; break;     /* mov --> movn.  */
24272     case 1189: value = 1188; break;     /* mov --> movz.  */
24273     case 1250: value = 1249; break;     /* autibsp --> autibz.  */
24274     case 1249: value = 1248; break;     /* autibz --> autiasp.  */
24275     case 1248: value = 1247; break;     /* autiasp --> autiaz.  */
24276     case 1247: value = 1246; break;     /* autiaz --> pacibsp.  */
24277     case 1246: value = 1245; break;     /* pacibsp --> pacibz.  */
24278     case 1245: value = 1244; break;     /* pacibz --> paciasp.  */
24279     case 1244: value = 1243; break;     /* paciasp --> paciaz.  */
24280     case 1243: value = 1219; break;     /* paciaz --> tsb.  */
24281     case 1219: value = 1218; break;     /* tsb --> psb.  */
24282     case 1218: value = 1217; break;     /* psb --> esb.  */
24283     case 1217: value = 1216; break;     /* esb --> autib1716.  */
24284     case 1216: value = 1215; break;     /* autib1716 --> autia1716.  */
24285     case 1215: value = 1214; break;     /* autia1716 --> pacib1716.  */
24286     case 1214: value = 1213; break;     /* pacib1716 --> pacia1716.  */
24287     case 1213: value = 1212; break;     /* pacia1716 --> xpaclri.  */
24288     case 1212: value = 1210; break;     /* xpaclri --> sevl.  */
24289     case 1210: value = 1209; break;     /* sevl --> sev.  */
24290     case 1209: value = 1208; break;     /* sev --> wfi.  */
24291     case 1208: value = 1207; break;     /* wfi --> wfe.  */
24292     case 1207: value = 1206; break;     /* wfe --> yield.  */
24293     case 1206: value = 1205; break;     /* yield --> bti.  */
24294     case 1205: value = 1204; break;     /* bti --> csdb.  */
24295     case 1204: value = 1203; break;     /* csdb --> nop.  */
24296     case 1203: value = 1202; break;     /* nop --> hint.  */
24297     case 1225: value = 1224; break;     /* pssbb --> ssbb.  */
24298     case 1224: value = 1223; break;     /* ssbb --> dfb.  */
24299     case 1223: value = 1221; break;     /* dfb --> dsb.  */
24300     case 1238: value = 1237; break;     /* cpp --> dvp.  */
24301     case 1237: value = 1236; break;     /* dvp --> cfp.  */
24302     case 1236: value = 1233; break;     /* cfp --> tlbi.  */
24303     case 1233: value = 1232; break;     /* tlbi --> ic.  */
24304     case 1232: value = 1231; break;     /* ic --> dc.  */
24305     case 1231: value = 1230; break;     /* dc --> at.  */
24306     case 1230: value = 1229; break;     /* at --> sys.  */
24307     case 2048: value = 1298; break;     /* bic --> and.  */
24308     case 1281: value = 1300; break;     /* mov --> and.  */
24309     case 1285: value = 1301; break;     /* movs --> ands.  */
24310     case 2049: value = 1336; break;     /* cmple --> cmpge.  */
24311     case 2052: value = 1339; break;     /* cmplt --> cmpgt.  */
24312     case 2050: value = 1341; break;     /* cmplo --> cmphi.  */
24313     case 2051: value = 1344; break;     /* cmpls --> cmphs.  */
24314     case 1278: value = 1366; break;     /* mov --> cpy.  */
24315     case 1280: value = 1367; break;     /* mov --> cpy.  */
24316     case 2059: value = 1283; break;     /* fmov --> mov.  */
24317     case 1283: value = 1368; break;     /* mov --> cpy.  */
24318     case 1273: value = 1380; break;     /* mov --> dup.  */
24319     case 1275: value = 1272; break;     /* mov --> mov.  */
24320     case 1272: value = 1381; break;     /* mov --> dup.  */
24321     case 2058: value = 1277; break;     /* fmov --> mov.  */
24322     case 1277: value = 1382; break;     /* mov --> dup.  */
24323     case 1276: value = 1383; break;     /* mov --> dupm.  */
24324     case 2053: value = 1385; break;     /* eon --> eor.  */
24325     case 1286: value = 1387; break;     /* not --> eor.  */
24326     case 1287: value = 1388; break;     /* nots --> eors.  */
24327     case 2054: value = 1393; break;     /* facle --> facge.  */
24328     case 2055: value = 1394; break;     /* faclt --> facgt.  */
24329     case 2056: value = 1407; break;     /* fcmle --> fcmge.  */
24330     case 2057: value = 1409; break;     /* fcmlt --> fcmgt.  */
24331     case 1270: value = 1415; break;     /* fmov --> fcpy.  */
24332     case 1269: value = 1438; break;     /* fmov --> fdup.  */
24333     case 1271: value = 1769; break;     /* mov --> orr.  */
24334     case 2060: value = 1770; break;     /* orn --> orr.  */
24335     case 1274: value = 1772; break;     /* mov --> orr.  */
24336     case 1284: value = 1773; break;     /* movs --> orrs.  */
24337     case 1279: value = 1835; break;     /* mov --> sel.  */
24338     case 1282: value = 1836; break;     /* mov --> sel.  */
24339     default: return NULL;
24340     }
24341
24342   return aarch64_opcode_table + value;
24343 }
24344
24345 bool
24346 aarch64_extract_operand (const aarch64_operand *self,
24347                            aarch64_opnd_info *info,
24348                            aarch64_insn code, const aarch64_inst *inst,
24349                            aarch64_operand_error *errors)
24350 {
24351   /* Use the index as the key.  */
24352   int key = self - aarch64_operands;
24353   switch (key)
24354     {
24355     case 1:
24356     case 2:
24357     case 3:
24358     case 4:
24359     case 5:
24360     case 6:
24361     case 7:
24362     case 8:
24363     case 9:
24364     case 11:
24365     case 12:
24366     case 13:
24367     case 17:
24368     case 18:
24369     case 19:
24370     case 20:
24371     case 22:
24372     case 23:
24373     case 24:
24374     case 25:
24375     case 26:
24376     case 27:
24377     case 28:
24378     case 29:
24379     case 30:
24380     case 31:
24381     case 167:
24382     case 168:
24383     case 169:
24384     case 170:
24385     case 171:
24386     case 172:
24387     case 173:
24388     case 174:
24389     case 175:
24390     case 176:
24391     case 191:
24392     case 192:
24393     case 193:
24394     case 194:
24395     case 195:
24396     case 196:
24397     case 197:
24398     case 198:
24399     case 199:
24400     case 205:
24401     case 208:
24402     case 210:
24403     case 211:
24404     case 214:
24405       return aarch64_ext_regno (self, info, code, inst, errors);
24406     case 10:
24407       return aarch64_ext_regrt_sysins (self, info, code, inst, errors);
24408     case 14:
24409       return aarch64_ext_regno_pair (self, info, code, inst, errors);
24410     case 15:
24411       return aarch64_ext_reg_extended (self, info, code, inst, errors);
24412     case 16:
24413       return aarch64_ext_reg_shifted (self, info, code, inst, errors);
24414     case 21:
24415       return aarch64_ext_ft (self, info, code, inst, errors);
24416     case 32:
24417     case 33:
24418     case 34:
24419     case 35:
24420     case 222:
24421       return aarch64_ext_reglane (self, info, code, inst, errors);
24422     case 36:
24423       return aarch64_ext_reglist (self, info, code, inst, errors);
24424     case 37:
24425       return aarch64_ext_ldst_reglist (self, info, code, inst, errors);
24426     case 38:
24427       return aarch64_ext_ldst_reglist_r (self, info, code, inst, errors);
24428     case 39:
24429       return aarch64_ext_ldst_elemlist (self, info, code, inst, errors);
24430     case 40:
24431     case 41:
24432     case 42:
24433     case 43:
24434     case 53:
24435     case 54:
24436     case 55:
24437     case 56:
24438     case 57:
24439     case 58:
24440     case 59:
24441     case 60:
24442     case 61:
24443     case 62:
24444     case 63:
24445     case 64:
24446     case 65:
24447     case 66:
24448     case 67:
24449     case 68:
24450     case 69:
24451     case 80:
24452     case 81:
24453     case 82:
24454     case 83:
24455     case 84:
24456     case 164:
24457     case 166:
24458     case 183:
24459     case 184:
24460     case 185:
24461     case 186:
24462     case 187:
24463     case 188:
24464     case 189:
24465     case 190:
24466     case 215:
24467     case 221:
24468       return aarch64_ext_imm (self, info, code, inst, errors);
24469     case 44:
24470     case 45:
24471       return aarch64_ext_advsimd_imm_shift (self, info, code, inst, errors);
24472     case 46:
24473     case 47:
24474     case 48:
24475       return aarch64_ext_advsimd_imm_modified (self, info, code, inst, errors);
24476     case 49:
24477       return aarch64_ext_shll_imm (self, info, code, inst, errors);
24478     case 52:
24479     case 154:
24480       return aarch64_ext_fpimm (self, info, code, inst, errors);
24481     case 70:
24482     case 162:
24483       return aarch64_ext_limm (self, info, code, inst, errors);
24484     case 71:
24485       return aarch64_ext_aimm (self, info, code, inst, errors);
24486     case 72:
24487       return aarch64_ext_imm_half (self, info, code, inst, errors);
24488     case 73:
24489       return aarch64_ext_fbits (self, info, code, inst, errors);
24490     case 75:
24491     case 76:
24492     case 159:
24493       return aarch64_ext_imm_rotate2 (self, info, code, inst, errors);
24494     case 77:
24495     case 158:
24496     case 160:
24497       return aarch64_ext_imm_rotate1 (self, info, code, inst, errors);
24498     case 78:
24499     case 79:
24500       return aarch64_ext_cond (self, info, code, inst, errors);
24501     case 85:
24502     case 94:
24503       return aarch64_ext_addr_simple (self, info, code, inst, errors);
24504     case 86:
24505       return aarch64_ext_addr_regoff (self, info, code, inst, errors);
24506     case 87:
24507     case 88:
24508     case 89:
24509     case 91:
24510     case 93:
24511       return aarch64_ext_addr_simm (self, info, code, inst, errors);
24512     case 90:
24513       return aarch64_ext_addr_simm10 (self, info, code, inst, errors);
24514     case 92:
24515       return aarch64_ext_addr_uimm12 (self, info, code, inst, errors);
24516     case 95:
24517       return aarch64_ext_addr_offset (self, info, code, inst, errors);
24518     case 96:
24519       return aarch64_ext_simd_addr_post (self, info, code, inst, errors);
24520     case 97:
24521       return aarch64_ext_sysreg (self, info, code, inst, errors);
24522     case 98:
24523       return aarch64_ext_pstatefield (self, info, code, inst, errors);
24524     case 99:
24525     case 100:
24526     case 101:
24527     case 102:
24528     case 103:
24529       return aarch64_ext_sysins_op (self, info, code, inst, errors);
24530     case 104:
24531     case 106:
24532       return aarch64_ext_barrier (self, info, code, inst, errors);
24533     case 105:
24534       return aarch64_ext_barrier_dsb_nxs (self, info, code, inst, errors);
24535     case 107:
24536       return aarch64_ext_prfop (self, info, code, inst, errors);
24537     case 108:
24538       return aarch64_ext_none (self, info, code, inst, errors);
24539     case 109:
24540       return aarch64_ext_hint (self, info, code, inst, errors);
24541     case 110:
24542     case 111:
24543       return aarch64_ext_sve_addr_ri_s4 (self, info, code, inst, errors);
24544     case 112:
24545     case 113:
24546     case 114:
24547     case 115:
24548       return aarch64_ext_sve_addr_ri_s4xvl (self, info, code, inst, errors);
24549     case 116:
24550       return aarch64_ext_sve_addr_ri_s6xvl (self, info, code, inst, errors);
24551     case 117:
24552       return aarch64_ext_sve_addr_ri_s9xvl (self, info, code, inst, errors);
24553     case 118:
24554     case 119:
24555     case 120:
24556     case 121:
24557       return aarch64_ext_sve_addr_ri_u6 (self, info, code, inst, errors);
24558     case 122:
24559     case 123:
24560     case 124:
24561     case 125:
24562     case 126:
24563     case 127:
24564     case 128:
24565     case 129:
24566     case 130:
24567     case 131:
24568     case 132:
24569     case 133:
24570     case 134:
24571     case 135:
24572     case 136:
24573       return aarch64_ext_sve_addr_rr_lsl (self, info, code, inst, errors);
24574     case 137:
24575     case 138:
24576     case 139:
24577     case 140:
24578     case 141:
24579     case 142:
24580     case 143:
24581     case 144:
24582       return aarch64_ext_sve_addr_rz_xtw (self, info, code, inst, errors);
24583     case 145:
24584     case 146:
24585     case 147:
24586     case 148:
24587       return aarch64_ext_sve_addr_zi_u5 (self, info, code, inst, errors);
24588     case 149:
24589       return aarch64_ext_sve_addr_zz_lsl (self, info, code, inst, errors);
24590     case 150:
24591       return aarch64_ext_sve_addr_zz_sxtw (self, info, code, inst, errors);
24592     case 151:
24593       return aarch64_ext_sve_addr_zz_uxtw (self, info, code, inst, errors);
24594     case 152:
24595       return aarch64_ext_sve_aimm (self, info, code, inst, errors);
24596     case 153:
24597       return aarch64_ext_sve_asimm (self, info, code, inst, errors);
24598     case 155:
24599       return aarch64_ext_sve_float_half_one (self, info, code, inst, errors);
24600     case 156:
24601       return aarch64_ext_sve_float_half_two (self, info, code, inst, errors);
24602     case 157:
24603       return aarch64_ext_sve_float_zero_one (self, info, code, inst, errors);
24604     case 161:
24605       return aarch64_ext_inv_limm (self, info, code, inst, errors);
24606     case 163:
24607       return aarch64_ext_sve_limm_mov (self, info, code, inst, errors);
24608     case 165:
24609       return aarch64_ext_sve_scale (self, info, code, inst, errors);
24610     case 177:
24611     case 178:
24612     case 179:
24613       return aarch64_ext_sve_shlimm (self, info, code, inst, errors);
24614     case 180:
24615     case 181:
24616     case 182:
24617       return aarch64_ext_sve_shrimm (self, info, code, inst, errors);
24618     case 200:
24619     case 201:
24620     case 202:
24621     case 203:
24622     case 204:
24623       return aarch64_ext_sve_quad_index (self, info, code, inst, errors);
24624     case 206:
24625       return aarch64_ext_sve_index (self, info, code, inst, errors);
24626     case 207:
24627     case 209:
24628       return aarch64_ext_sve_reglist (self, info, code, inst, errors);
24629     case 212:
24630     case 213:
24631     case 216:
24632       return aarch64_ext_sme_za_hv_tiles (self, info, code, inst, errors);
24633     case 217:
24634       return aarch64_ext_sme_za_array (self, info, code, inst, errors);
24635     case 218:
24636       return aarch64_ext_sme_addr_ri_u4xvl (self, info, code, inst, errors);
24637     case 219:
24638       return aarch64_ext_sme_sm_za (self, info, code, inst, errors);
24639     case 220:
24640       return aarch64_ext_sme_pred_reg_with_index (self, info, code, inst, errors);
24641     default: assert (0); abort ();
24642     }
24643 }