xref: /netbsd-src/external/gpl3/gdb/dist/opcodes/aarch64-dis-2.c (revision d536862b7d93d77932ef5de7eebdc48d76921b77)
1 /* This file is automatically generated by aarch64-gen.  Do not edit!  */
2 /* Copyright (C) 2012-2020 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                       /* 33222222222211111111110000000000
40                          10987654321098765432109876543210
41                          xxx00000xxxxxxxxxxxxxxxxxxxxxxxx
42                          udf.  */
43                       return 754;
44                     }
45                   else
46                     {
47                       if (((word >> 31) & 0x1) == 0)
48                         {
49                           /* 33222222222211111111110000000000
50                              10987654321098765432109876543210
51                              0xx10000xxxxxxxxxxxxxxxxxxxxxxxx
52                              adr.  */
53                           return 1187;
54                         }
55                       else
56                         {
57                           /* 33222222222211111111110000000000
58                              10987654321098765432109876543210
59                              1xx10000xxxxxxxxxxxxxxxxxxxxxxxx
60                              adrp.  */
61                           return 1188;
62                         }
63                     }
64                 }
65               else
66                 {
67                   if (((word >> 29) & 0x1) == 0)
68                     {
69                       if (((word >> 30) & 0x1) == 0)
70                         {
71                           /* 33222222222211111111110000000000
72                              10987654321098765432109876543210
73                              x00x0001xxxxxxxxxxxxxxxxxxxxxxxx
74                              add.  */
75                           return 12;
76                         }
77                       else
78                         {
79                           /* 33222222222211111111110000000000
80                              10987654321098765432109876543210
81                              x10x0001xxxxxxxxxxxxxxxxxxxxxxxx
82                              sub.  */
83                           return 16;
84                         }
85                     }
86                   else
87                     {
88                       if (((word >> 30) & 0x1) == 0)
89                         {
90                           /* 33222222222211111111110000000000
91                              10987654321098765432109876543210
92                              x01x0001xxxxxxxxxxxxxxxxxxxxxxxx
93                              adds.  */
94                           return 14;
95                         }
96                       else
97                         {
98                           /* 33222222222211111111110000000000
99                              10987654321098765432109876543210
100                              x11x0001xxxxxxxxxxxxxxxxxxxxxxxx
101                              subs.  */
102                           return 17;
103                         }
104                     }
105                 }
106             }
107           else
108             {
109               if (((word >> 28) & 0x1) == 0)
110                 {
111                   if (((word >> 22) & 0x1) == 0)
112                     {
113                       if (((word >> 23) & 0x1) == 0)
114                         {
115                           if (((word >> 29) & 0x1) == 0)
116                             {
117                               if (((word >> 15) & 0x1) == 0)
118                                 {
119                                   if (((word >> 21) & 0x1) == 0)
120                                     {
121                                       if (((word >> 31) & 0x1) == 0)
122                                         {
123                                           if (((word >> 30) & 0x1) == 0)
124                                             {
125                                               /* 33222222222211111111110000000000
126                                                  10987654321098765432109876543210
127                                                  0000100x000xxxxx0xxxxxxxxxxxxxxx
128                                                  stxrb.  */
129                                               return 937;
130                                             }
131                                           else
132                                             {
133                                               /* 33222222222211111111110000000000
134                                                  10987654321098765432109876543210
135                                                  0100100x000xxxxx0xxxxxxxxxxxxxxx
136                                                  stxrh.  */
137                                               return 943;
138                                             }
139                                         }
140                                       else
141                                         {
142                                           /* 33222222222211111111110000000000
143                                              10987654321098765432109876543210
144                                              1x00100x000xxxxx0xxxxxxxxxxxxxxx
145                                              stxr.  */
146                                           return 949;
147                                         }
148                                     }
149                                   else
150                                     {
151                                       if (((word >> 31) & 0x1) == 0)
152                                         {
153                                           /* 33222222222211111111110000000000
154                                              10987654321098765432109876543210
155                                              0x00100x001xxxxx0xxxxxxxxxxxxxxx
156                                              casp.  */
157                                           return 1022;
158                                         }
159                                       else
160                                         {
161                                           /* 33222222222211111111110000000000
162                                              10987654321098765432109876543210
163                                              1x00100x001xxxxx0xxxxxxxxxxxxxxx
164                                              stxp.  */
165                                           return 951;
166                                         }
167                                     }
168                                 }
169                               else
170                                 {
171                                   if (((word >> 21) & 0x1) == 0)
172                                     {
173                                       if (((word >> 31) & 0x1) == 0)
174                                         {
175                                           if (((word >> 30) & 0x1) == 0)
176                                             {
177                                               /* 33222222222211111111110000000000
178                                                  10987654321098765432109876543210
179                                                  0000100x000xxxxx1xxxxxxxxxxxxxxx
180                                                  stlxrb.  */
181                                               return 938;
182                                             }
183                                           else
184                                             {
185                                               /* 33222222222211111111110000000000
186                                                  10987654321098765432109876543210
187                                                  0100100x000xxxxx1xxxxxxxxxxxxxxx
188                                                  stlxrh.  */
189                                               return 944;
190                                             }
191                                         }
192                                       else
193                                         {
194                                           /* 33222222222211111111110000000000
195                                              10987654321098765432109876543210
196                                              1x00100x000xxxxx1xxxxxxxxxxxxxxx
197                                              stlxr.  */
198                                           return 950;
199                                         }
200                                     }
201                                   else
202                                     {
203                                       if (((word >> 31) & 0x1) == 0)
204                                         {
205                                           /* 33222222222211111111110000000000
206                                              10987654321098765432109876543210
207                                              0x00100x001xxxxx1xxxxxxxxxxxxxxx
208                                              caspl.  */
209                                           return 1024;
210                                         }
211                                       else
212                                         {
213                                           /* 33222222222211111111110000000000
214                                              10987654321098765432109876543210
215                                              1x00100x001xxxxx1xxxxxxxxxxxxxxx
216                                              stlxp.  */
217                                           return 952;
218                                         }
219                                     }
220                                 }
221                             }
222                           else
223                             {
224                               if (((word >> 30) & 0x1) == 0)
225                                 {
226                                   /* 33222222222211111111110000000000
227                                      10987654321098765432109876543210
228                                      x010100x00xxxxxxxxxxxxxxxxxxxxxx
229                                      stnp.  */
230                                   return 971;
231                                 }
232                               else
233                                 {
234                                   /* 33222222222211111111110000000000
235                                      10987654321098765432109876543210
236                                      x110100x00xxxxxxxxxxxxxxxxxxxxxx
237                                      stgp.  */
238                                   return 980;
239                                 }
240                             }
241                         }
242                       else
243                         {
244                           if (((word >> 29) & 0x1) == 0)
245                             {
246                               if (((word >> 15) & 0x1) == 0)
247                                 {
248                                   if (((word >> 21) & 0x1) == 0)
249                                     {
250                                       if (((word >> 31) & 0x1) == 0)
251                                         {
252                                           /* 33222222222211111111110000000000
253                                              10987654321098765432109876543210
254                                              0x00100x100xxxxx0xxxxxxxxxxxxxxx
255                                              stllrb.  */
256                                           return 969;
257                                         }
258                                       else
259                                         {
260                                           /* 33222222222211111111110000000000
261                                              10987654321098765432109876543210
262                                              1x00100x100xxxxx0xxxxxxxxxxxxxxx
263                                              stllr.  */
264                                           return 968;
265                                         }
266                                     }
267                                   else
268                                     {
269                                       if (((word >> 31) & 0x1) == 0)
270                                         {
271                                           if (((word >> 30) & 0x1) == 0)
272                                             {
273                                               /* 33222222222211111111110000000000
274                                                  10987654321098765432109876543210
275                                                  0000100x101xxxxx0xxxxxxxxxxxxxxx
276                                                  casb.  */
277                                               return 1010;
278                                             }
279                                           else
280                                             {
281                                               /* 33222222222211111111110000000000
282                                                  10987654321098765432109876543210
283                                                  0100100x101xxxxx0xxxxxxxxxxxxxxx
284                                                  cash.  */
285                                               return 1011;
286                                             }
287                                         }
288                                       else
289                                         {
290                                           /* 33222222222211111111110000000000
291                                              10987654321098765432109876543210
292                                              1x00100x101xxxxx0xxxxxxxxxxxxxxx
293                                              cas.  */
294                                           return 1012;
295                                         }
296                                     }
297                                 }
298                               else
299                                 {
300                                   if (((word >> 21) & 0x1) == 0)
301                                     {
302                                       if (((word >> 31) & 0x1) == 0)
303                                         {
304                                           if (((word >> 30) & 0x1) == 0)
305                                             {
306                                               /* 33222222222211111111110000000000
307                                                  10987654321098765432109876543210
308                                                  0000100x100xxxxx1xxxxxxxxxxxxxxx
309                                                  stlrb.  */
310                                               return 941;
311                                             }
312                                           else
313                                             {
314                                               /* 33222222222211111111110000000000
315                                                  10987654321098765432109876543210
316                                                  0100100x100xxxxx1xxxxxxxxxxxxxxx
317                                                  stlrh.  */
318                                               return 947;
319                                             }
320                                         }
321                                       else
322                                         {
323                                           /* 33222222222211111111110000000000
324                                              10987654321098765432109876543210
325                                              1x00100x100xxxxx1xxxxxxxxxxxxxxx
326                                              stlr.  */
327                                           return 957;
328                                         }
329                                     }
330                                   else
331                                     {
332                                       if (((word >> 31) & 0x1) == 0)
333                                         {
334                                           if (((word >> 30) & 0x1) == 0)
335                                             {
336                                               /* 33222222222211111111110000000000
337                                                  10987654321098765432109876543210
338                                                  0000100x101xxxxx1xxxxxxxxxxxxxxx
339                                                  caslb.  */
340                                               return 1014;
341                                             }
342                                           else
343                                             {
344                                               /* 33222222222211111111110000000000
345                                                  10987654321098765432109876543210
346                                                  0100100x101xxxxx1xxxxxxxxxxxxxxx
347                                                  caslh.  */
348                                               return 1017;
349                                             }
350                                         }
351                                       else
352                                         {
353                                           /* 33222222222211111111110000000000
354                                              10987654321098765432109876543210
355                                              1x00100x101xxxxx1xxxxxxxxxxxxxxx
356                                              casl.  */
357                                           return 1020;
358                                         }
359                                     }
360                                 }
361                             }
362                           else
363                             {
364                               if (((word >> 30) & 0x1) == 0)
365                                 {
366                                   /* 33222222222211111111110000000000
367                                      10987654321098765432109876543210
368                                      x010100x10xxxxxxxxxxxxxxxxxxxxxx
369                                      stp.  */
370                                   return 981;
371                                 }
372                               else
373                                 {
374                                   /* 33222222222211111111110000000000
375                                      10987654321098765432109876543210
376                                      x110100x10xxxxxxxxxxxxxxxxxxxxxx
377                                      stgp.  */
378                                   return 986;
379                                 }
380                             }
381                         }
382                     }
383                   else
384                     {
385                       if (((word >> 23) & 0x1) == 0)
386                         {
387                           if (((word >> 29) & 0x1) == 0)
388                             {
389                               if (((word >> 15) & 0x1) == 0)
390                                 {
391                                   if (((word >> 21) & 0x1) == 0)
392                                     {
393                                       if (((word >> 31) & 0x1) == 0)
394                                         {
395                                           if (((word >> 30) & 0x1) == 0)
396                                             {
397                                               /* 33222222222211111111110000000000
398                                                  10987654321098765432109876543210
399                                                  0000100x010xxxxx0xxxxxxxxxxxxxxx
400                                                  ldxrb.  */
401                                               return 939;
402                                             }
403                                           else
404                                             {
405                                               /* 33222222222211111111110000000000
406                                                  10987654321098765432109876543210
407                                                  0100100x010xxxxx0xxxxxxxxxxxxxxx
408                                                  ldxrh.  */
409                                               return 945;
410                                             }
411                                         }
412                                       else
413                                         {
414                                           /* 33222222222211111111110000000000
415                                              10987654321098765432109876543210
416                                              1x00100x010xxxxx0xxxxxxxxxxxxxxx
417                                              ldxr.  */
418                                           return 953;
419                                         }
420                                     }
421                                   else
422                                     {
423                                       if (((word >> 31) & 0x1) == 0)
424                                         {
425                                           /* 33222222222211111111110000000000
426                                              10987654321098765432109876543210
427                                              0x00100x011xxxxx0xxxxxxxxxxxxxxx
428                                              caspa.  */
429                                           return 1023;
430                                         }
431                                       else
432                                         {
433                                           /* 33222222222211111111110000000000
434                                              10987654321098765432109876543210
435                                              1x00100x011xxxxx0xxxxxxxxxxxxxxx
436                                              ldxp.  */
437                                           return 955;
438                                         }
439                                     }
440                                 }
441                               else
442                                 {
443                                   if (((word >> 21) & 0x1) == 0)
444                                     {
445                                       if (((word >> 31) & 0x1) == 0)
446                                         {
447                                           if (((word >> 30) & 0x1) == 0)
448                                             {
449                                               /* 33222222222211111111110000000000
450                                                  10987654321098765432109876543210
451                                                  0000100x010xxxxx1xxxxxxxxxxxxxxx
452                                                  ldaxrb.  */
453                                               return 940;
454                                             }
455                                           else
456                                             {
457                                               /* 33222222222211111111110000000000
458                                                  10987654321098765432109876543210
459                                                  0100100x010xxxxx1xxxxxxxxxxxxxxx
460                                                  ldaxrh.  */
461                                               return 946;
462                                             }
463                                         }
464                                       else
465                                         {
466                                           /* 33222222222211111111110000000000
467                                              10987654321098765432109876543210
468                                              1x00100x010xxxxx1xxxxxxxxxxxxxxx
469                                              ldaxr.  */
470                                           return 954;
471                                         }
472                                     }
473                                   else
474                                     {
475                                       if (((word >> 31) & 0x1) == 0)
476                                         {
477                                           /* 33222222222211111111110000000000
478                                              10987654321098765432109876543210
479                                              0x00100x011xxxxx1xxxxxxxxxxxxxxx
480                                              caspal.  */
481                                           return 1025;
482                                         }
483                                       else
484                                         {
485                                           /* 33222222222211111111110000000000
486                                              10987654321098765432109876543210
487                                              1x00100x011xxxxx1xxxxxxxxxxxxxxx
488                                              ldaxp.  */
489                                           return 956;
490                                         }
491                                     }
492                                 }
493                             }
494                           else
495                             {
496                               if (((word >> 30) & 0x1) == 0)
497                                 {
498                                   /* 33222222222211111111110000000000
499                                      10987654321098765432109876543210
500                                      x010100x01xxxxxxxxxxxxxxxxxxxxxx
501                                      ldnp.  */
502                                   return 972;
503                                 }
504                               else
505                                 {
506                                   /* 33222222222211111111110000000000
507                                      10987654321098765432109876543210
508                                      x110100x01xxxxxxxxxxxxxxxxxxxxxx
509                                      ldpsw.  */
510                                   return 979;
511                                 }
512                             }
513                         }
514                       else
515                         {
516                           if (((word >> 29) & 0x1) == 0)
517                             {
518                               if (((word >> 15) & 0x1) == 0)
519                                 {
520                                   if (((word >> 21) & 0x1) == 0)
521                                     {
522                                       if (((word >> 31) & 0x1) == 0)
523                                         {
524                                           if (((word >> 30) & 0x1) == 0)
525                                             {
526                                               /* 33222222222211111111110000000000
527                                                  10987654321098765432109876543210
528                                                  0000100x110xxxxx0xxxxxxxxxxxxxxx
529                                                  ldlarb.  */
530                                               return 966;
531                                             }
532                                           else
533                                             {
534                                               /* 33222222222211111111110000000000
535                                                  10987654321098765432109876543210
536                                                  0100100x110xxxxx0xxxxxxxxxxxxxxx
537                                                  ldlarh.  */
538                                               return 967;
539                                             }
540                                         }
541                                       else
542                                         {
543                                           /* 33222222222211111111110000000000
544                                              10987654321098765432109876543210
545                                              1x00100x110xxxxx0xxxxxxxxxxxxxxx
546                                              ldlar.  */
547                                           return 965;
548                                         }
549                                     }
550                                   else
551                                     {
552                                       if (((word >> 31) & 0x1) == 0)
553                                         {
554                                           if (((word >> 30) & 0x1) == 0)
555                                             {
556                                               /* 33222222222211111111110000000000
557                                                  10987654321098765432109876543210
558                                                  0000100x111xxxxx0xxxxxxxxxxxxxxx
559                                                  casab.  */
560                                               return 1013;
561                                             }
562                                           else
563                                             {
564                                               /* 33222222222211111111110000000000
565                                                  10987654321098765432109876543210
566                                                  0100100x111xxxxx0xxxxxxxxxxxxxxx
567                                                  casah.  */
568                                               return 1016;
569                                             }
570                                         }
571                                       else
572                                         {
573                                           /* 33222222222211111111110000000000
574                                              10987654321098765432109876543210
575                                              1x00100x111xxxxx0xxxxxxxxxxxxxxx
576                                              casa.  */
577                                           return 1019;
578                                         }
579                                     }
580                                 }
581                               else
582                                 {
583                                   if (((word >> 21) & 0x1) == 0)
584                                     {
585                                       if (((word >> 31) & 0x1) == 0)
586                                         {
587                                           if (((word >> 30) & 0x1) == 0)
588                                             {
589                                               /* 33222222222211111111110000000000
590                                                  10987654321098765432109876543210
591                                                  0000100x110xxxxx1xxxxxxxxxxxxxxx
592                                                  ldarb.  */
593                                               return 942;
594                                             }
595                                           else
596                                             {
597                                               /* 33222222222211111111110000000000
598                                                  10987654321098765432109876543210
599                                                  0100100x110xxxxx1xxxxxxxxxxxxxxx
600                                                  ldarh.  */
601                                               return 948;
602                                             }
603                                         }
604                                       else
605                                         {
606                                           /* 33222222222211111111110000000000
607                                              10987654321098765432109876543210
608                                              1x00100x110xxxxx1xxxxxxxxxxxxxxx
609                                              ldar.  */
610                                           return 958;
611                                         }
612                                     }
613                                   else
614                                     {
615                                       if (((word >> 31) & 0x1) == 0)
616                                         {
617                                           if (((word >> 30) & 0x1) == 0)
618                                             {
619                                               /* 33222222222211111111110000000000
620                                                  10987654321098765432109876543210
621                                                  0000100x111xxxxx1xxxxxxxxxxxxxxx
622                                                  casalb.  */
623                                               return 1015;
624                                             }
625                                           else
626                                             {
627                                               /* 33222222222211111111110000000000
628                                                  10987654321098765432109876543210
629                                                  0100100x111xxxxx1xxxxxxxxxxxxxxx
630                                                  casalh.  */
631                                               return 1018;
632                                             }
633                                         }
634                                       else
635                                         {
636                                           /* 33222222222211111111110000000000
637                                              10987654321098765432109876543210
638                                              1x00100x111xxxxx1xxxxxxxxxxxxxxx
639                                              casal.  */
640                                           return 1021;
641                                         }
642                                     }
643                                 }
644                             }
645                           else
646                             {
647                               if (((word >> 30) & 0x1) == 0)
648                                 {
649                                   /* 33222222222211111111110000000000
650                                      10987654321098765432109876543210
651                                      x010100x11xxxxxxxxxxxxxxxxxxxxxx
652                                      ldp.  */
653                                   return 982;
654                                 }
655                               else
656                                 {
657                                   /* 33222222222211111111110000000000
658                                      10987654321098765432109876543210
659                                      x110100x11xxxxxxxxxxxxxxxxxxxxxx
660                                      ldpsw.  */
661                                   return 985;
662                                 }
663                             }
664                         }
665                     }
666                 }
667               else
668                 {
669                   if (((word >> 24) & 0x1) == 0)
670                     {
671                       if (((word >> 29) & 0x1) == 0)
672                         {
673                           if (((word >> 31) & 0x1) == 0)
674                             {
675                               /* 33222222222211111111110000000000
676                                  10987654321098765432109876543210
677                                  0x011000xxxxxxxxxxxxxxxxxxxxxxxx
678                                  ldr.  */
679                               return 987;
680                             }
681                           else
682                             {
683                               if (((word >> 30) & 0x1) == 0)
684                                 {
685                                   /* 33222222222211111111110000000000
686                                      10987654321098765432109876543210
687                                      10011000xxxxxxxxxxxxxxxxxxxxxxxx
688                                      ldrsw.  */
689                                   return 989;
690                                 }
691                               else
692                                 {
693                                   /* 33222222222211111111110000000000
694                                      10987654321098765432109876543210
695                                      11011000xxxxxxxxxxxxxxxxxxxxxxxx
696                                      prfm.  */
697                                   return 990;
698                                 }
699                             }
700                         }
701                       else
702                         {
703                           if (((word >> 10) & 0x1) == 0)
704                             {
705                               if (((word >> 11) & 0x1) == 0)
706                                 {
707                                   if (((word >> 21) & 0x1) == 0)
708                                     {
709                                       if (((word >> 23) & 0x1) == 0)
710                                         {
711                                           if (((word >> 22) & 0x1) == 0)
712                                             {
713                                               if (((word >> 31) & 0x1) == 0)
714                                                 {
715                                                   if (((word >> 30) & 0x1) == 0)
716                                                     {
717                                                       /* 33222222222211111111110000000000
718                                                          10987654321098765432109876543210
719                                                          00111000000xxxxxxxxx00xxxxxxxxxx
720                                                          sturb.  */
721                                                       return 922;
722                                                     }
723                                                   else
724                                                     {
725                                                       /* 33222222222211111111110000000000
726                                                          10987654321098765432109876543210
727                                                          01111000000xxxxxxxxx00xxxxxxxxxx
728                                                          sturh.  */
729                                                       return 927;
730                                                     }
731                                                 }
732                                               else
733                                                 {
734                                                   /* 33222222222211111111110000000000
735                                                      10987654321098765432109876543210
736                                                      1x111000000xxxxxxxxx00xxxxxxxxxx
737                                                      stur.  */
738                                                   return 930;
739                                                 }
740                                             }
741                                           else
742                                             {
743                                               if (((word >> 31) & 0x1) == 0)
744                                                 {
745                                                   if (((word >> 30) & 0x1) == 0)
746                                                     {
747                                                       /* 33222222222211111111110000000000
748                                                          10987654321098765432109876543210
749                                                          00111000010xxxxxxxxx00xxxxxxxxxx
750                                                          ldurb.  */
751                                                       return 923;
752                                                     }
753                                                   else
754                                                     {
755                                                       /* 33222222222211111111110000000000
756                                                          10987654321098765432109876543210
757                                                          01111000010xxxxxxxxx00xxxxxxxxxx
758                                                          ldurh.  */
759                                                       return 928;
760                                                     }
761                                                 }
762                                               else
763                                                 {
764                                                   /* 33222222222211111111110000000000
765                                                      10987654321098765432109876543210
766                                                      1x111000010xxxxxxxxx00xxxxxxxxxx
767                                                      ldur.  */
768                                                   return 931;
769                                                 }
770                                             }
771                                         }
772                                       else
773                                         {
774                                           if (((word >> 30) & 0x1) == 0)
775                                             {
776                                               if (((word >> 31) & 0x1) == 0)
777                                                 {
778                                                   /* 33222222222211111111110000000000
779                                                      10987654321098765432109876543210
780                                                      001110001x0xxxxxxxxx00xxxxxxxxxx
781                                                      ldursb.  */
782                                                   return 924;
783                                                 }
784                                               else
785                                                 {
786                                                   /* 33222222222211111111110000000000
787                                                      10987654321098765432109876543210
788                                                      101110001x0xxxxxxxxx00xxxxxxxxxx
789                                                      ldursw.  */
790                                                   return 932;
791                                                 }
792                                             }
793                                           else
794                                             {
795                                               if (((word >> 31) & 0x1) == 0)
796                                                 {
797                                                   /* 33222222222211111111110000000000
798                                                      10987654321098765432109876543210
799                                                      011110001x0xxxxxxxxx00xxxxxxxxxx
800                                                      ldursh.  */
801                                                   return 929;
802                                                 }
803                                               else
804                                                 {
805                                                   /* 33222222222211111111110000000000
806                                                      10987654321098765432109876543210
807                                                      111110001x0xxxxxxxxx00xxxxxxxxxx
808                                                      prfum.  */
809                                                   return 933;
810                                                 }
811                                             }
812                                         }
813                                     }
814                                   else
815                                     {
816                                       if (((word >> 12) & 0x1) == 0)
817                                         {
818                                           if (((word >> 13) & 0x1) == 0)
819                                             {
820                                               if (((word >> 14) & 0x1) == 0)
821                                                 {
822                                                   if (((word >> 15) & 0x1) == 0)
823                                                     {
824                                                       if (((word >> 22) & 0x1) == 0)
825                                                         {
826                                                           if (((word >> 23) & 0x1) == 0)
827                                                             {
828                                                               if (((word >> 31) & 0x1) == 0)
829                                                                 {
830                                                                   if (((word >> 30) & 0x1) == 0)
831                                                                     {
832                                                                       /* 33222222222211111111110000000000
833                                                                          10987654321098765432109876543210
834                                                                          00111000001xxxxx000000xxxxxxxxxx
835                                                                          ldaddb.  */
836                                                                       return 1038;
837                                                                     }
838                                                                   else
839                                                                     {
840                                                                       /* 33222222222211111111110000000000
841                                                                          10987654321098765432109876543210
842                                                                          01111000001xxxxx000000xxxxxxxxxx
843                                                                          ldaddh.  */
844                                                                       return 1039;
845                                                                     }
846                                                                 }
847                                                               else
848                                                                 {
849                                                                   /* 33222222222211111111110000000000
850                                                                      10987654321098765432109876543210
851                                                                      1x111000001xxxxx000000xxxxxxxxxx
852                                                                      ldadd.  */
853                                                                   return 1040;
854                                                                 }
855                                                             }
856                                                           else
857                                                             {
858                                                               if (((word >> 31) & 0x1) == 0)
859                                                                 {
860                                                                   if (((word >> 30) & 0x1) == 0)
861                                                                     {
862                                                                       /* 33222222222211111111110000000000
863                                                                          10987654321098765432109876543210
864                                                                          00111000101xxxxx000000xxxxxxxxxx
865                                                                          ldaddab.  */
866                                                                       return 1041;
867                                                                     }
868                                                                   else
869                                                                     {
870                                                                       /* 33222222222211111111110000000000
871                                                                          10987654321098765432109876543210
872                                                                          01111000101xxxxx000000xxxxxxxxxx
873                                                                          ldaddah.  */
874                                                                       return 1044;
875                                                                     }
876                                                                 }
877                                                               else
878                                                                 {
879                                                                   /* 33222222222211111111110000000000
880                                                                      10987654321098765432109876543210
881                                                                      1x111000101xxxxx000000xxxxxxxxxx
882                                                                      ldadda.  */
883                                                                   return 1047;
884                                                                 }
885                                                             }
886                                                         }
887                                                       else
888                                                         {
889                                                           if (((word >> 23) & 0x1) == 0)
890                                                             {
891                                                               if (((word >> 31) & 0x1) == 0)
892                                                                 {
893                                                                   if (((word >> 30) & 0x1) == 0)
894                                                                     {
895                                                                       /* 33222222222211111111110000000000
896                                                                          10987654321098765432109876543210
897                                                                          00111000011xxxxx000000xxxxxxxxxx
898                                                                          ldaddlb.  */
899                                                                       return 1042;
900                                                                     }
901                                                                   else
902                                                                     {
903                                                                       /* 33222222222211111111110000000000
904                                                                          10987654321098765432109876543210
905                                                                          01111000011xxxxx000000xxxxxxxxxx
906                                                                          ldaddlh.  */
907                                                                       return 1045;
908                                                                     }
909                                                                 }
910                                                               else
911                                                                 {
912                                                                   /* 33222222222211111111110000000000
913                                                                      10987654321098765432109876543210
914                                                                      1x111000011xxxxx000000xxxxxxxxxx
915                                                                      ldaddl.  */
916                                                                   return 1048;
917                                                                 }
918                                                             }
919                                                           else
920                                                             {
921                                                               if (((word >> 31) & 0x1) == 0)
922                                                                 {
923                                                                   if (((word >> 30) & 0x1) == 0)
924                                                                     {
925                                                                       /* 33222222222211111111110000000000
926                                                                          10987654321098765432109876543210
927                                                                          00111000111xxxxx000000xxxxxxxxxx
928                                                                          ldaddalb.  */
929                                                                       return 1043;
930                                                                     }
931                                                                   else
932                                                                     {
933                                                                       /* 33222222222211111111110000000000
934                                                                          10987654321098765432109876543210
935                                                                          01111000111xxxxx000000xxxxxxxxxx
936                                                                          ldaddalh.  */
937                                                                       return 1046;
938                                                                     }
939                                                                 }
940                                                               else
941                                                                 {
942                                                                   /* 33222222222211111111110000000000
943                                                                      10987654321098765432109876543210
944                                                                      1x111000111xxxxx000000xxxxxxxxxx
945                                                                      ldaddal.  */
946                                                                   return 1049;
947                                                                 }
948                                                             }
949                                                         }
950                                                     }
951                                                   else
952                                                     {
953                                                       if (((word >> 22) & 0x1) == 0)
954                                                         {
955                                                           if (((word >> 23) & 0x1) == 0)
956                                                             {
957                                                               if (((word >> 31) & 0x1) == 0)
958                                                                 {
959                                                                   if (((word >> 30) & 0x1) == 0)
960                                                                     {
961                                                                       /* 33222222222211111111110000000000
962                                                                          10987654321098765432109876543210
963                                                                          00111000001xxxxx100000xxxxxxxxxx
964                                                                          swpb.  */
965                                                                       return 1026;
966                                                                     }
967                                                                   else
968                                                                     {
969                                                                       /* 33222222222211111111110000000000
970                                                                          10987654321098765432109876543210
971                                                                          01111000001xxxxx100000xxxxxxxxxx
972                                                                          swph.  */
973                                                                       return 1027;
974                                                                     }
975                                                                 }
976                                                               else
977                                                                 {
978                                                                   /* 33222222222211111111110000000000
979                                                                      10987654321098765432109876543210
980                                                                      1x111000001xxxxx100000xxxxxxxxxx
981                                                                      swp.  */
982                                                                   return 1028;
983                                                                 }
984                                                             }
985                                                           else
986                                                             {
987                                                               if (((word >> 31) & 0x1) == 0)
988                                                                 {
989                                                                   if (((word >> 30) & 0x1) == 0)
990                                                                     {
991                                                                       /* 33222222222211111111110000000000
992                                                                          10987654321098765432109876543210
993                                                                          00111000101xxxxx100000xxxxxxxxxx
994                                                                          swpab.  */
995                                                                       return 1029;
996                                                                     }
997                                                                   else
998                                                                     {
999                                                                       /* 33222222222211111111110000000000
1000                                                                          10987654321098765432109876543210
1001                                                                          01111000101xxxxx100000xxxxxxxxxx
1002                                                                          swpah.  */
1003                                                                       return 1032;
1004                                                                     }
1005                                                                 }
1006                                                               else
1007                                                                 {
1008                                                                   /* 33222222222211111111110000000000
1009                                                                      10987654321098765432109876543210
1010                                                                      1x111000101xxxxx100000xxxxxxxxxx
1011                                                                      swpa.  */
1012                                                                   return 1035;
1013                                                                 }
1014                                                             }
1015                                                         }
1016                                                       else
1017                                                         {
1018                                                           if (((word >> 23) & 0x1) == 0)
1019                                                             {
1020                                                               if (((word >> 31) & 0x1) == 0)
1021                                                                 {
1022                                                                   if (((word >> 30) & 0x1) == 0)
1023                                                                     {
1024                                                                       /* 33222222222211111111110000000000
1025                                                                          10987654321098765432109876543210
1026                                                                          00111000011xxxxx100000xxxxxxxxxx
1027                                                                          swplb.  */
1028                                                                       return 1030;
1029                                                                     }
1030                                                                   else
1031                                                                     {
1032                                                                       /* 33222222222211111111110000000000
1033                                                                          10987654321098765432109876543210
1034                                                                          01111000011xxxxx100000xxxxxxxxxx
1035                                                                          swplh.  */
1036                                                                       return 1033;
1037                                                                     }
1038                                                                 }
1039                                                               else
1040                                                                 {
1041                                                                   /* 33222222222211111111110000000000
1042                                                                      10987654321098765432109876543210
1043                                                                      1x111000011xxxxx100000xxxxxxxxxx
1044                                                                      swpl.  */
1045                                                                   return 1036;
1046                                                                 }
1047                                                             }
1048                                                           else
1049                                                             {
1050                                                               if (((word >> 31) & 0x1) == 0)
1051                                                                 {
1052                                                                   if (((word >> 30) & 0x1) == 0)
1053                                                                     {
1054                                                                       /* 33222222222211111111110000000000
1055                                                                          10987654321098765432109876543210
1056                                                                          00111000111xxxxx100000xxxxxxxxxx
1057                                                                          swpalb.  */
1058                                                                       return 1031;
1059                                                                     }
1060                                                                   else
1061                                                                     {
1062                                                                       /* 33222222222211111111110000000000
1063                                                                          10987654321098765432109876543210
1064                                                                          01111000111xxxxx100000xxxxxxxxxx
1065                                                                          swpalh.  */
1066                                                                       return 1034;
1067                                                                     }
1068                                                                 }
1069                                                               else
1070                                                                 {
1071                                                                   /* 33222222222211111111110000000000
1072                                                                      10987654321098765432109876543210
1073                                                                      1x111000111xxxxx100000xxxxxxxxxx
1074                                                                      swpal.  */
1075                                                                   return 1037;
1076                                                                 }
1077                                                             }
1078                                                         }
1079                                                     }
1080                                                 }
1081                                               else
1082                                                 {
1083                                                   if (((word >> 15) & 0x1) == 0)
1084                                                     {
1085                                                       if (((word >> 22) & 0x1) == 0)
1086                                                         {
1087                                                           if (((word >> 23) & 0x1) == 0)
1088                                                             {
1089                                                               if (((word >> 31) & 0x1) == 0)
1090                                                                 {
1091                                                                   if (((word >> 30) & 0x1) == 0)
1092                                                                     {
1093                                                                       /* 33222222222211111111110000000000
1094                                                                          10987654321098765432109876543210
1095                                                                          00111000001xxxxx010000xxxxxxxxxx
1096                                                                          ldsmaxb.  */
1097                                                                       return 1086;
1098                                                                     }
1099                                                                   else
1100                                                                     {
1101                                                                       /* 33222222222211111111110000000000
1102                                                                          10987654321098765432109876543210
1103                                                                          01111000001xxxxx010000xxxxxxxxxx
1104                                                                          ldsmaxh.  */
1105                                                                       return 1087;
1106                                                                     }
1107                                                                 }
1108                                                               else
1109                                                                 {
1110                                                                   /* 33222222222211111111110000000000
1111                                                                      10987654321098765432109876543210
1112                                                                      1x111000001xxxxx010000xxxxxxxxxx
1113                                                                      ldsmax.  */
1114                                                                   return 1088;
1115                                                                 }
1116                                                             }
1117                                                           else
1118                                                             {
1119                                                               if (((word >> 31) & 0x1) == 0)
1120                                                                 {
1121                                                                   if (((word >> 30) & 0x1) == 0)
1122                                                                     {
1123                                                                       /* 33222222222211111111110000000000
1124                                                                          10987654321098765432109876543210
1125                                                                          00111000101xxxxx010000xxxxxxxxxx
1126                                                                          ldsmaxab.  */
1127                                                                       return 1089;
1128                                                                     }
1129                                                                   else
1130                                                                     {
1131                                                                       /* 33222222222211111111110000000000
1132                                                                          10987654321098765432109876543210
1133                                                                          01111000101xxxxx010000xxxxxxxxxx
1134                                                                          ldsmaxah.  */
1135                                                                       return 1092;
1136                                                                     }
1137                                                                 }
1138                                                               else
1139                                                                 {
1140                                                                   /* 33222222222211111111110000000000
1141                                                                      10987654321098765432109876543210
1142                                                                      1x111000101xxxxx010000xxxxxxxxxx
1143                                                                      ldsmaxa.  */
1144                                                                   return 1095;
1145                                                                 }
1146                                                             }
1147                                                         }
1148                                                       else
1149                                                         {
1150                                                           if (((word >> 23) & 0x1) == 0)
1151                                                             {
1152                                                               if (((word >> 31) & 0x1) == 0)
1153                                                                 {
1154                                                                   if (((word >> 30) & 0x1) == 0)
1155                                                                     {
1156                                                                       /* 33222222222211111111110000000000
1157                                                                          10987654321098765432109876543210
1158                                                                          00111000011xxxxx010000xxxxxxxxxx
1159                                                                          ldsmaxlb.  */
1160                                                                       return 1090;
1161                                                                     }
1162                                                                   else
1163                                                                     {
1164                                                                       /* 33222222222211111111110000000000
1165                                                                          10987654321098765432109876543210
1166                                                                          01111000011xxxxx010000xxxxxxxxxx
1167                                                                          ldsmaxlh.  */
1168                                                                       return 1093;
1169                                                                     }
1170                                                                 }
1171                                                               else
1172                                                                 {
1173                                                                   /* 33222222222211111111110000000000
1174                                                                      10987654321098765432109876543210
1175                                                                      1x111000011xxxxx010000xxxxxxxxxx
1176                                                                      ldsmaxl.  */
1177                                                                   return 1096;
1178                                                                 }
1179                                                             }
1180                                                           else
1181                                                             {
1182                                                               if (((word >> 31) & 0x1) == 0)
1183                                                                 {
1184                                                                   if (((word >> 30) & 0x1) == 0)
1185                                                                     {
1186                                                                       /* 33222222222211111111110000000000
1187                                                                          10987654321098765432109876543210
1188                                                                          00111000111xxxxx010000xxxxxxxxxx
1189                                                                          ldsmaxalb.  */
1190                                                                       return 1091;
1191                                                                     }
1192                                                                   else
1193                                                                     {
1194                                                                       /* 33222222222211111111110000000000
1195                                                                          10987654321098765432109876543210
1196                                                                          01111000111xxxxx010000xxxxxxxxxx
1197                                                                          ldsmaxalh.  */
1198                                                                       return 1094;
1199                                                                     }
1200                                                                 }
1201                                                               else
1202                                                                 {
1203                                                                   /* 33222222222211111111110000000000
1204                                                                      10987654321098765432109876543210
1205                                                                      1x111000111xxxxx010000xxxxxxxxxx
1206                                                                      ldsmaxal.  */
1207                                                                   return 1097;
1208                                                                 }
1209                                                             }
1210                                                         }
1211                                                     }
1212                                                   else
1213                                                     {
1214                                                       if (((word >> 31) & 0x1) == 0)
1215                                                         {
1216                                                           if (((word >> 30) & 0x1) == 0)
1217                                                             {
1218                                                               /* 33222222222211111111110000000000
1219                                                                  10987654321098765432109876543210
1220                                                                  00111000xx1xxxxx110000xxxxxxxxxx
1221                                                                  ldaprb.  */
1222                                                               return 959;
1223                                                             }
1224                                                           else
1225                                                             {
1226                                                               /* 33222222222211111111110000000000
1227                                                                  10987654321098765432109876543210
1228                                                                  01111000xx1xxxxx110000xxxxxxxxxx
1229                                                                  ldaprh.  */
1230                                                               return 960;
1231                                                             }
1232                                                         }
1233                                                       else
1234                                                         {
1235                                                           /* 33222222222211111111110000000000
1236                                                              10987654321098765432109876543210
1237                                                              1x111000xx1xxxxx110000xxxxxxxxxx
1238                                                              ldapr.  */
1239                                                           return 961;
1240                                                         }
1241                                                     }
1242                                                 }
1243                                             }
1244                                           else
1245                                             {
1246                                               if (((word >> 14) & 0x1) == 0)
1247                                                 {
1248                                                   if (((word >> 22) & 0x1) == 0)
1249                                                     {
1250                                                       if (((word >> 23) & 0x1) == 0)
1251                                                         {
1252                                                           if (((word >> 31) & 0x1) == 0)
1253                                                             {
1254                                                               if (((word >> 30) & 0x1) == 0)
1255                                                                 {
1256                                                                   /* 33222222222211111111110000000000
1257                                                                      10987654321098765432109876543210
1258                                                                      00111000001xxxxxx01000xxxxxxxxxx
1259                                                                      ldeorb.  */
1260                                                                   return 1062;
1261                                                                 }
1262                                                               else
1263                                                                 {
1264                                                                   /* 33222222222211111111110000000000
1265                                                                      10987654321098765432109876543210
1266                                                                      01111000001xxxxxx01000xxxxxxxxxx
1267                                                                      ldeorh.  */
1268                                                                   return 1063;
1269                                                                 }
1270                                                             }
1271                                                           else
1272                                                             {
1273                                                               /* 33222222222211111111110000000000
1274                                                                  10987654321098765432109876543210
1275                                                                  1x111000001xxxxxx01000xxxxxxxxxx
1276                                                                  ldeor.  */
1277                                                               return 1064;
1278                                                             }
1279                                                         }
1280                                                       else
1281                                                         {
1282                                                           if (((word >> 31) & 0x1) == 0)
1283                                                             {
1284                                                               if (((word >> 30) & 0x1) == 0)
1285                                                                 {
1286                                                                   /* 33222222222211111111110000000000
1287                                                                      10987654321098765432109876543210
1288                                                                      00111000101xxxxxx01000xxxxxxxxxx
1289                                                                      ldeorab.  */
1290                                                                   return 1065;
1291                                                                 }
1292                                                               else
1293                                                                 {
1294                                                                   /* 33222222222211111111110000000000
1295                                                                      10987654321098765432109876543210
1296                                                                      01111000101xxxxxx01000xxxxxxxxxx
1297                                                                      ldeorah.  */
1298                                                                   return 1068;
1299                                                                 }
1300                                                             }
1301                                                           else
1302                                                             {
1303                                                               /* 33222222222211111111110000000000
1304                                                                  10987654321098765432109876543210
1305                                                                  1x111000101xxxxxx01000xxxxxxxxxx
1306                                                                  ldeora.  */
1307                                                               return 1071;
1308                                                             }
1309                                                         }
1310                                                     }
1311                                                   else
1312                                                     {
1313                                                       if (((word >> 23) & 0x1) == 0)
1314                                                         {
1315                                                           if (((word >> 31) & 0x1) == 0)
1316                                                             {
1317                                                               if (((word >> 30) & 0x1) == 0)
1318                                                                 {
1319                                                                   /* 33222222222211111111110000000000
1320                                                                      10987654321098765432109876543210
1321                                                                      00111000011xxxxxx01000xxxxxxxxxx
1322                                                                      ldeorlb.  */
1323                                                                   return 1066;
1324                                                                 }
1325                                                               else
1326                                                                 {
1327                                                                   /* 33222222222211111111110000000000
1328                                                                      10987654321098765432109876543210
1329                                                                      01111000011xxxxxx01000xxxxxxxxxx
1330                                                                      ldeorlh.  */
1331                                                                   return 1069;
1332                                                                 }
1333                                                             }
1334                                                           else
1335                                                             {
1336                                                               /* 33222222222211111111110000000000
1337                                                                  10987654321098765432109876543210
1338                                                                  1x111000011xxxxxx01000xxxxxxxxxx
1339                                                                  ldeorl.  */
1340                                                               return 1072;
1341                                                             }
1342                                                         }
1343                                                       else
1344                                                         {
1345                                                           if (((word >> 31) & 0x1) == 0)
1346                                                             {
1347                                                               if (((word >> 30) & 0x1) == 0)
1348                                                                 {
1349                                                                   /* 33222222222211111111110000000000
1350                                                                      10987654321098765432109876543210
1351                                                                      00111000111xxxxxx01000xxxxxxxxxx
1352                                                                      ldeoralb.  */
1353                                                                   return 1067;
1354                                                                 }
1355                                                               else
1356                                                                 {
1357                                                                   /* 33222222222211111111110000000000
1358                                                                      10987654321098765432109876543210
1359                                                                      01111000111xxxxxx01000xxxxxxxxxx
1360                                                                      ldeoralh.  */
1361                                                                   return 1070;
1362                                                                 }
1363                                                             }
1364                                                           else
1365                                                             {
1366                                                               /* 33222222222211111111110000000000
1367                                                                  10987654321098765432109876543210
1368                                                                  1x111000111xxxxxx01000xxxxxxxxxx
1369                                                                  ldeoral.  */
1370                                                               return 1073;
1371                                                             }
1372                                                         }
1373                                                     }
1374                                                 }
1375                                               else
1376                                                 {
1377                                                   if (((word >> 22) & 0x1) == 0)
1378                                                     {
1379                                                       if (((word >> 23) & 0x1) == 0)
1380                                                         {
1381                                                           if (((word >> 31) & 0x1) == 0)
1382                                                             {
1383                                                               if (((word >> 30) & 0x1) == 0)
1384                                                                 {
1385                                                                   /* 33222222222211111111110000000000
1386                                                                      10987654321098765432109876543210
1387                                                                      00111000001xxxxxx11000xxxxxxxxxx
1388                                                                      ldumaxb.  */
1389                                                                   return 1110;
1390                                                                 }
1391                                                               else
1392                                                                 {
1393                                                                   /* 33222222222211111111110000000000
1394                                                                      10987654321098765432109876543210
1395                                                                      01111000001xxxxxx11000xxxxxxxxxx
1396                                                                      ldumaxh.  */
1397                                                                   return 1111;
1398                                                                 }
1399                                                             }
1400                                                           else
1401                                                             {
1402                                                               /* 33222222222211111111110000000000
1403                                                                  10987654321098765432109876543210
1404                                                                  1x111000001xxxxxx11000xxxxxxxxxx
1405                                                                  ldumax.  */
1406                                                               return 1112;
1407                                                             }
1408                                                         }
1409                                                       else
1410                                                         {
1411                                                           if (((word >> 31) & 0x1) == 0)
1412                                                             {
1413                                                               if (((word >> 30) & 0x1) == 0)
1414                                                                 {
1415                                                                   /* 33222222222211111111110000000000
1416                                                                      10987654321098765432109876543210
1417                                                                      00111000101xxxxxx11000xxxxxxxxxx
1418                                                                      ldumaxab.  */
1419                                                                   return 1113;
1420                                                                 }
1421                                                               else
1422                                                                 {
1423                                                                   /* 33222222222211111111110000000000
1424                                                                      10987654321098765432109876543210
1425                                                                      01111000101xxxxxx11000xxxxxxxxxx
1426                                                                      ldumaxah.  */
1427                                                                   return 1116;
1428                                                                 }
1429                                                             }
1430                                                           else
1431                                                             {
1432                                                               /* 33222222222211111111110000000000
1433                                                                  10987654321098765432109876543210
1434                                                                  1x111000101xxxxxx11000xxxxxxxxxx
1435                                                                  ldumaxa.  */
1436                                                               return 1119;
1437                                                             }
1438                                                         }
1439                                                     }
1440                                                   else
1441                                                     {
1442                                                       if (((word >> 23) & 0x1) == 0)
1443                                                         {
1444                                                           if (((word >> 31) & 0x1) == 0)
1445                                                             {
1446                                                               if (((word >> 30) & 0x1) == 0)
1447                                                                 {
1448                                                                   /* 33222222222211111111110000000000
1449                                                                      10987654321098765432109876543210
1450                                                                      00111000011xxxxxx11000xxxxxxxxxx
1451                                                                      ldumaxlb.  */
1452                                                                   return 1114;
1453                                                                 }
1454                                                               else
1455                                                                 {
1456                                                                   /* 33222222222211111111110000000000
1457                                                                      10987654321098765432109876543210
1458                                                                      01111000011xxxxxx11000xxxxxxxxxx
1459                                                                      ldumaxlh.  */
1460                                                                   return 1117;
1461                                                                 }
1462                                                             }
1463                                                           else
1464                                                             {
1465                                                               /* 33222222222211111111110000000000
1466                                                                  10987654321098765432109876543210
1467                                                                  1x111000011xxxxxx11000xxxxxxxxxx
1468                                                                  ldumaxl.  */
1469                                                               return 1120;
1470                                                             }
1471                                                         }
1472                                                       else
1473                                                         {
1474                                                           if (((word >> 31) & 0x1) == 0)
1475                                                             {
1476                                                               if (((word >> 30) & 0x1) == 0)
1477                                                                 {
1478                                                                   /* 33222222222211111111110000000000
1479                                                                      10987654321098765432109876543210
1480                                                                      00111000111xxxxxx11000xxxxxxxxxx
1481                                                                      ldumaxalb.  */
1482                                                                   return 1115;
1483                                                                 }
1484                                                               else
1485                                                                 {
1486                                                                   /* 33222222222211111111110000000000
1487                                                                      10987654321098765432109876543210
1488                                                                      01111000111xxxxxx11000xxxxxxxxxx
1489                                                                      ldumaxalh.  */
1490                                                                   return 1118;
1491                                                                 }
1492                                                             }
1493                                                           else
1494                                                             {
1495                                                               /* 33222222222211111111110000000000
1496                                                                  10987654321098765432109876543210
1497                                                                  1x111000111xxxxxx11000xxxxxxxxxx
1498                                                                  ldumaxal.  */
1499                                                               return 1121;
1500                                                             }
1501                                                         }
1502                                                     }
1503                                                 }
1504                                             }
1505                                         }
1506                                       else
1507                                         {
1508                                           if (((word >> 13) & 0x1) == 0)
1509                                             {
1510                                               if (((word >> 14) & 0x1) == 0)
1511                                                 {
1512                                                   if (((word >> 22) & 0x1) == 0)
1513                                                     {
1514                                                       if (((word >> 23) & 0x1) == 0)
1515                                                         {
1516                                                           if (((word >> 31) & 0x1) == 0)
1517                                                             {
1518                                                               if (((word >> 30) & 0x1) == 0)
1519                                                                 {
1520                                                                   /* 33222222222211111111110000000000
1521                                                                      10987654321098765432109876543210
1522                                                                      00111000001xxxxxx00100xxxxxxxxxx
1523                                                                      ldclrb.  */
1524                                                                   return 1050;
1525                                                                 }
1526                                                               else
1527                                                                 {
1528                                                                   /* 33222222222211111111110000000000
1529                                                                      10987654321098765432109876543210
1530                                                                      01111000001xxxxxx00100xxxxxxxxxx
1531                                                                      ldclrh.  */
1532                                                                   return 1051;
1533                                                                 }
1534                                                             }
1535                                                           else
1536                                                             {
1537                                                               /* 33222222222211111111110000000000
1538                                                                  10987654321098765432109876543210
1539                                                                  1x111000001xxxxxx00100xxxxxxxxxx
1540                                                                  ldclr.  */
1541                                                               return 1052;
1542                                                             }
1543                                                         }
1544                                                       else
1545                                                         {
1546                                                           if (((word >> 31) & 0x1) == 0)
1547                                                             {
1548                                                               if (((word >> 30) & 0x1) == 0)
1549                                                                 {
1550                                                                   /* 33222222222211111111110000000000
1551                                                                      10987654321098765432109876543210
1552                                                                      00111000101xxxxxx00100xxxxxxxxxx
1553                                                                      ldclrab.  */
1554                                                                   return 1053;
1555                                                                 }
1556                                                               else
1557                                                                 {
1558                                                                   /* 33222222222211111111110000000000
1559                                                                      10987654321098765432109876543210
1560                                                                      01111000101xxxxxx00100xxxxxxxxxx
1561                                                                      ldclrah.  */
1562                                                                   return 1056;
1563                                                                 }
1564                                                             }
1565                                                           else
1566                                                             {
1567                                                               /* 33222222222211111111110000000000
1568                                                                  10987654321098765432109876543210
1569                                                                  1x111000101xxxxxx00100xxxxxxxxxx
1570                                                                  ldclra.  */
1571                                                               return 1059;
1572                                                             }
1573                                                         }
1574                                                     }
1575                                                   else
1576                                                     {
1577                                                       if (((word >> 23) & 0x1) == 0)
1578                                                         {
1579                                                           if (((word >> 31) & 0x1) == 0)
1580                                                             {
1581                                                               if (((word >> 30) & 0x1) == 0)
1582                                                                 {
1583                                                                   /* 33222222222211111111110000000000
1584                                                                      10987654321098765432109876543210
1585                                                                      00111000011xxxxxx00100xxxxxxxxxx
1586                                                                      ldclrlb.  */
1587                                                                   return 1054;
1588                                                                 }
1589                                                               else
1590                                                                 {
1591                                                                   /* 33222222222211111111110000000000
1592                                                                      10987654321098765432109876543210
1593                                                                      01111000011xxxxxx00100xxxxxxxxxx
1594                                                                      ldclrlh.  */
1595                                                                   return 1057;
1596                                                                 }
1597                                                             }
1598                                                           else
1599                                                             {
1600                                                               /* 33222222222211111111110000000000
1601                                                                  10987654321098765432109876543210
1602                                                                  1x111000011xxxxxx00100xxxxxxxxxx
1603                                                                  ldclrl.  */
1604                                                               return 1060;
1605                                                             }
1606                                                         }
1607                                                       else
1608                                                         {
1609                                                           if (((word >> 31) & 0x1) == 0)
1610                                                             {
1611                                                               if (((word >> 30) & 0x1) == 0)
1612                                                                 {
1613                                                                   /* 33222222222211111111110000000000
1614                                                                      10987654321098765432109876543210
1615                                                                      00111000111xxxxxx00100xxxxxxxxxx
1616                                                                      ldclralb.  */
1617                                                                   return 1055;
1618                                                                 }
1619                                                               else
1620                                                                 {
1621                                                                   /* 33222222222211111111110000000000
1622                                                                      10987654321098765432109876543210
1623                                                                      01111000111xxxxxx00100xxxxxxxxxx
1624                                                                      ldclralh.  */
1625                                                                   return 1058;
1626                                                                 }
1627                                                             }
1628                                                           else
1629                                                             {
1630                                                               /* 33222222222211111111110000000000
1631                                                                  10987654321098765432109876543210
1632                                                                  1x111000111xxxxxx00100xxxxxxxxxx
1633                                                                  ldclral.  */
1634                                                               return 1061;
1635                                                             }
1636                                                         }
1637                                                     }
1638                                                 }
1639                                               else
1640                                                 {
1641                                                   if (((word >> 22) & 0x1) == 0)
1642                                                     {
1643                                                       if (((word >> 23) & 0x1) == 0)
1644                                                         {
1645                                                           if (((word >> 31) & 0x1) == 0)
1646                                                             {
1647                                                               if (((word >> 30) & 0x1) == 0)
1648                                                                 {
1649                                                                   /* 33222222222211111111110000000000
1650                                                                      10987654321098765432109876543210
1651                                                                      00111000001xxxxxx10100xxxxxxxxxx
1652                                                                      ldsminb.  */
1653                                                                   return 1098;
1654                                                                 }
1655                                                               else
1656                                                                 {
1657                                                                   /* 33222222222211111111110000000000
1658                                                                      10987654321098765432109876543210
1659                                                                      01111000001xxxxxx10100xxxxxxxxxx
1660                                                                      ldsminh.  */
1661                                                                   return 1099;
1662                                                                 }
1663                                                             }
1664                                                           else
1665                                                             {
1666                                                               /* 33222222222211111111110000000000
1667                                                                  10987654321098765432109876543210
1668                                                                  1x111000001xxxxxx10100xxxxxxxxxx
1669                                                                  ldsmin.  */
1670                                                               return 1100;
1671                                                             }
1672                                                         }
1673                                                       else
1674                                                         {
1675                                                           if (((word >> 31) & 0x1) == 0)
1676                                                             {
1677                                                               if (((word >> 30) & 0x1) == 0)
1678                                                                 {
1679                                                                   /* 33222222222211111111110000000000
1680                                                                      10987654321098765432109876543210
1681                                                                      00111000101xxxxxx10100xxxxxxxxxx
1682                                                                      ldsminab.  */
1683                                                                   return 1101;
1684                                                                 }
1685                                                               else
1686                                                                 {
1687                                                                   /* 33222222222211111111110000000000
1688                                                                      10987654321098765432109876543210
1689                                                                      01111000101xxxxxx10100xxxxxxxxxx
1690                                                                      ldsminah.  */
1691                                                                   return 1104;
1692                                                                 }
1693                                                             }
1694                                                           else
1695                                                             {
1696                                                               /* 33222222222211111111110000000000
1697                                                                  10987654321098765432109876543210
1698                                                                  1x111000101xxxxxx10100xxxxxxxxxx
1699                                                                  ldsmina.  */
1700                                                               return 1107;
1701                                                             }
1702                                                         }
1703                                                     }
1704                                                   else
1705                                                     {
1706                                                       if (((word >> 23) & 0x1) == 0)
1707                                                         {
1708                                                           if (((word >> 31) & 0x1) == 0)
1709                                                             {
1710                                                               if (((word >> 30) & 0x1) == 0)
1711                                                                 {
1712                                                                   /* 33222222222211111111110000000000
1713                                                                      10987654321098765432109876543210
1714                                                                      00111000011xxxxxx10100xxxxxxxxxx
1715                                                                      ldsminlb.  */
1716                                                                   return 1102;
1717                                                                 }
1718                                                               else
1719                                                                 {
1720                                                                   /* 33222222222211111111110000000000
1721                                                                      10987654321098765432109876543210
1722                                                                      01111000011xxxxxx10100xxxxxxxxxx
1723                                                                      ldsminlh.  */
1724                                                                   return 1105;
1725                                                                 }
1726                                                             }
1727                                                           else
1728                                                             {
1729                                                               /* 33222222222211111111110000000000
1730                                                                  10987654321098765432109876543210
1731                                                                  1x111000011xxxxxx10100xxxxxxxxxx
1732                                                                  ldsminl.  */
1733                                                               return 1108;
1734                                                             }
1735                                                         }
1736                                                       else
1737                                                         {
1738                                                           if (((word >> 31) & 0x1) == 0)
1739                                                             {
1740                                                               if (((word >> 30) & 0x1) == 0)
1741                                                                 {
1742                                                                   /* 33222222222211111111110000000000
1743                                                                      10987654321098765432109876543210
1744                                                                      00111000111xxxxxx10100xxxxxxxxxx
1745                                                                      ldsminalb.  */
1746                                                                   return 1103;
1747                                                                 }
1748                                                               else
1749                                                                 {
1750                                                                   /* 33222222222211111111110000000000
1751                                                                      10987654321098765432109876543210
1752                                                                      01111000111xxxxxx10100xxxxxxxxxx
1753                                                                      ldsminalh.  */
1754                                                                   return 1106;
1755                                                                 }
1756                                                             }
1757                                                           else
1758                                                             {
1759                                                               /* 33222222222211111111110000000000
1760                                                                  10987654321098765432109876543210
1761                                                                  1x111000111xxxxxx10100xxxxxxxxxx
1762                                                                  ldsminal.  */
1763                                                               return 1109;
1764                                                             }
1765                                                         }
1766                                                     }
1767                                                 }
1768                                             }
1769                                           else
1770                                             {
1771                                               if (((word >> 14) & 0x1) == 0)
1772                                                 {
1773                                                   if (((word >> 22) & 0x1) == 0)
1774                                                     {
1775                                                       if (((word >> 23) & 0x1) == 0)
1776                                                         {
1777                                                           if (((word >> 31) & 0x1) == 0)
1778                                                             {
1779                                                               if (((word >> 30) & 0x1) == 0)
1780                                                                 {
1781                                                                   /* 33222222222211111111110000000000
1782                                                                      10987654321098765432109876543210
1783                                                                      00111000001xxxxxx01100xxxxxxxxxx
1784                                                                      ldsetb.  */
1785                                                                   return 1074;
1786                                                                 }
1787                                                               else
1788                                                                 {
1789                                                                   /* 33222222222211111111110000000000
1790                                                                      10987654321098765432109876543210
1791                                                                      01111000001xxxxxx01100xxxxxxxxxx
1792                                                                      ldseth.  */
1793                                                                   return 1075;
1794                                                                 }
1795                                                             }
1796                                                           else
1797                                                             {
1798                                                               /* 33222222222211111111110000000000
1799                                                                  10987654321098765432109876543210
1800                                                                  1x111000001xxxxxx01100xxxxxxxxxx
1801                                                                  ldset.  */
1802                                                               return 1076;
1803                                                             }
1804                                                         }
1805                                                       else
1806                                                         {
1807                                                           if (((word >> 31) & 0x1) == 0)
1808                                                             {
1809                                                               if (((word >> 30) & 0x1) == 0)
1810                                                                 {
1811                                                                   /* 33222222222211111111110000000000
1812                                                                      10987654321098765432109876543210
1813                                                                      00111000101xxxxxx01100xxxxxxxxxx
1814                                                                      ldsetab.  */
1815                                                                   return 1077;
1816                                                                 }
1817                                                               else
1818                                                                 {
1819                                                                   /* 33222222222211111111110000000000
1820                                                                      10987654321098765432109876543210
1821                                                                      01111000101xxxxxx01100xxxxxxxxxx
1822                                                                      ldsetah.  */
1823                                                                   return 1080;
1824                                                                 }
1825                                                             }
1826                                                           else
1827                                                             {
1828                                                               /* 33222222222211111111110000000000
1829                                                                  10987654321098765432109876543210
1830                                                                  1x111000101xxxxxx01100xxxxxxxxxx
1831                                                                  ldseta.  */
1832                                                               return 1083;
1833                                                             }
1834                                                         }
1835                                                     }
1836                                                   else
1837                                                     {
1838                                                       if (((word >> 23) & 0x1) == 0)
1839                                                         {
1840                                                           if (((word >> 31) & 0x1) == 0)
1841                                                             {
1842                                                               if (((word >> 30) & 0x1) == 0)
1843                                                                 {
1844                                                                   /* 33222222222211111111110000000000
1845                                                                      10987654321098765432109876543210
1846                                                                      00111000011xxxxxx01100xxxxxxxxxx
1847                                                                      ldsetlb.  */
1848                                                                   return 1078;
1849                                                                 }
1850                                                               else
1851                                                                 {
1852                                                                   /* 33222222222211111111110000000000
1853                                                                      10987654321098765432109876543210
1854                                                                      01111000011xxxxxx01100xxxxxxxxxx
1855                                                                      ldsetlh.  */
1856                                                                   return 1081;
1857                                                                 }
1858                                                             }
1859                                                           else
1860                                                             {
1861                                                               /* 33222222222211111111110000000000
1862                                                                  10987654321098765432109876543210
1863                                                                  1x111000011xxxxxx01100xxxxxxxxxx
1864                                                                  ldsetl.  */
1865                                                               return 1084;
1866                                                             }
1867                                                         }
1868                                                       else
1869                                                         {
1870                                                           if (((word >> 31) & 0x1) == 0)
1871                                                             {
1872                                                               if (((word >> 30) & 0x1) == 0)
1873                                                                 {
1874                                                                   /* 33222222222211111111110000000000
1875                                                                      10987654321098765432109876543210
1876                                                                      00111000111xxxxxx01100xxxxxxxxxx
1877                                                                      ldsetalb.  */
1878                                                                   return 1079;
1879                                                                 }
1880                                                               else
1881                                                                 {
1882                                                                   /* 33222222222211111111110000000000
1883                                                                      10987654321098765432109876543210
1884                                                                      01111000111xxxxxx01100xxxxxxxxxx
1885                                                                      ldsetalh.  */
1886                                                                   return 1082;
1887                                                                 }
1888                                                             }
1889                                                           else
1890                                                             {
1891                                                               /* 33222222222211111111110000000000
1892                                                                  10987654321098765432109876543210
1893                                                                  1x111000111xxxxxx01100xxxxxxxxxx
1894                                                                  ldsetal.  */
1895                                                               return 1085;
1896                                                             }
1897                                                         }
1898                                                     }
1899                                                 }
1900                                               else
1901                                                 {
1902                                                   if (((word >> 22) & 0x1) == 0)
1903                                                     {
1904                                                       if (((word >> 23) & 0x1) == 0)
1905                                                         {
1906                                                           if (((word >> 31) & 0x1) == 0)
1907                                                             {
1908                                                               if (((word >> 30) & 0x1) == 0)
1909                                                                 {
1910                                                                   /* 33222222222211111111110000000000
1911                                                                      10987654321098765432109876543210
1912                                                                      00111000001xxxxxx11100xxxxxxxxxx
1913                                                                      lduminb.  */
1914                                                                   return 1122;
1915                                                                 }
1916                                                               else
1917                                                                 {
1918                                                                   /* 33222222222211111111110000000000
1919                                                                      10987654321098765432109876543210
1920                                                                      01111000001xxxxxx11100xxxxxxxxxx
1921                                                                      lduminh.  */
1922                                                                   return 1123;
1923                                                                 }
1924                                                             }
1925                                                           else
1926                                                             {
1927                                                               /* 33222222222211111111110000000000
1928                                                                  10987654321098765432109876543210
1929                                                                  1x111000001xxxxxx11100xxxxxxxxxx
1930                                                                  ldumin.  */
1931                                                               return 1124;
1932                                                             }
1933                                                         }
1934                                                       else
1935                                                         {
1936                                                           if (((word >> 31) & 0x1) == 0)
1937                                                             {
1938                                                               if (((word >> 30) & 0x1) == 0)
1939                                                                 {
1940                                                                   /* 33222222222211111111110000000000
1941                                                                      10987654321098765432109876543210
1942                                                                      00111000101xxxxxx11100xxxxxxxxxx
1943                                                                      lduminab.  */
1944                                                                   return 1125;
1945                                                                 }
1946                                                               else
1947                                                                 {
1948                                                                   /* 33222222222211111111110000000000
1949                                                                      10987654321098765432109876543210
1950                                                                      01111000101xxxxxx11100xxxxxxxxxx
1951                                                                      lduminah.  */
1952                                                                   return 1128;
1953                                                                 }
1954                                                             }
1955                                                           else
1956                                                             {
1957                                                               /* 33222222222211111111110000000000
1958                                                                  10987654321098765432109876543210
1959                                                                  1x111000101xxxxxx11100xxxxxxxxxx
1960                                                                  ldumina.  */
1961                                                               return 1131;
1962                                                             }
1963                                                         }
1964                                                     }
1965                                                   else
1966                                                     {
1967                                                       if (((word >> 23) & 0x1) == 0)
1968                                                         {
1969                                                           if (((word >> 31) & 0x1) == 0)
1970                                                             {
1971                                                               if (((word >> 30) & 0x1) == 0)
1972                                                                 {
1973                                                                   /* 33222222222211111111110000000000
1974                                                                      10987654321098765432109876543210
1975                                                                      00111000011xxxxxx11100xxxxxxxxxx
1976                                                                      lduminlb.  */
1977                                                                   return 1126;
1978                                                                 }
1979                                                               else
1980                                                                 {
1981                                                                   /* 33222222222211111111110000000000
1982                                                                      10987654321098765432109876543210
1983                                                                      01111000011xxxxxx11100xxxxxxxxxx
1984                                                                      lduminlh.  */
1985                                                                   return 1129;
1986                                                                 }
1987                                                             }
1988                                                           else
1989                                                             {
1990                                                               /* 33222222222211111111110000000000
1991                                                                  10987654321098765432109876543210
1992                                                                  1x111000011xxxxxx11100xxxxxxxxxx
1993                                                                  lduminl.  */
1994                                                               return 1132;
1995                                                             }
1996                                                         }
1997                                                       else
1998                                                         {
1999                                                           if (((word >> 31) & 0x1) == 0)
2000                                                             {
2001                                                               if (((word >> 30) & 0x1) == 0)
2002                                                                 {
2003                                                                   /* 33222222222211111111110000000000
2004                                                                      10987654321098765432109876543210
2005                                                                      00111000111xxxxxx11100xxxxxxxxxx
2006                                                                      lduminalb.  */
2007                                                                   return 1127;
2008                                                                 }
2009                                                               else
2010                                                                 {
2011                                                                   /* 33222222222211111111110000000000
2012                                                                      10987654321098765432109876543210
2013                                                                      01111000111xxxxxx11100xxxxxxxxxx
2014                                                                      lduminalh.  */
2015                                                                   return 1130;
2016                                                                 }
2017                                                             }
2018                                                           else
2019                                                             {
2020                                                               /* 33222222222211111111110000000000
2021                                                                  10987654321098765432109876543210
2022                                                                  1x111000111xxxxxx11100xxxxxxxxxx
2023                                                                  lduminal.  */
2024                                                               return 1133;
2025                                                             }
2026                                                         }
2027                                                     }
2028                                                 }
2029                                             }
2030                                         }
2031                                     }
2032                                 }
2033                               else
2034                                 {
2035                                   if (((word >> 21) & 0x1) == 0)
2036                                     {
2037                                       if (((word >> 23) & 0x1) == 0)
2038                                         {
2039                                           if (((word >> 22) & 0x1) == 0)
2040                                             {
2041                                               if (((word >> 31) & 0x1) == 0)
2042                                                 {
2043                                                   if (((word >> 30) & 0x1) == 0)
2044                                                     {
2045                                                       /* 33222222222211111111110000000000
2046                                                          10987654321098765432109876543210
2047                                                          00111000000xxxxxxxxx10xxxxxxxxxx
2048                                                          sttrb.  */
2049                                                       return 913;
2050                                                     }
2051                                                   else
2052                                                     {
2053                                                       /* 33222222222211111111110000000000
2054                                                          10987654321098765432109876543210
2055                                                          01111000000xxxxxxxxx10xxxxxxxxxx
2056                                                          sttrh.  */
2057                                                       return 916;
2058                                                     }
2059                                                 }
2060                                               else
2061                                                 {
2062                                                   /* 33222222222211111111110000000000
2063                                                      10987654321098765432109876543210
2064                                                      1x111000000xxxxxxxxx10xxxxxxxxxx
2065                                                      sttr.  */
2066                                                   return 919;
2067                                                 }
2068                                             }
2069                                           else
2070                                             {
2071                                               if (((word >> 31) & 0x1) == 0)
2072                                                 {
2073                                                   if (((word >> 30) & 0x1) == 0)
2074                                                     {
2075                                                       /* 33222222222211111111110000000000
2076                                                          10987654321098765432109876543210
2077                                                          00111000010xxxxxxxxx10xxxxxxxxxx
2078                                                          ldtrb.  */
2079                                                       return 914;
2080                                                     }
2081                                                   else
2082                                                     {
2083                                                       /* 33222222222211111111110000000000
2084                                                          10987654321098765432109876543210
2085                                                          01111000010xxxxxxxxx10xxxxxxxxxx
2086                                                          ldtrh.  */
2087                                                       return 917;
2088                                                     }
2089                                                 }
2090                                               else
2091                                                 {
2092                                                   /* 33222222222211111111110000000000
2093                                                      10987654321098765432109876543210
2094                                                      1x111000010xxxxxxxxx10xxxxxxxxxx
2095                                                      ldtr.  */
2096                                                   return 920;
2097                                                 }
2098                                             }
2099                                         }
2100                                       else
2101                                         {
2102                                           if (((word >> 30) & 0x1) == 0)
2103                                             {
2104                                               if (((word >> 31) & 0x1) == 0)
2105                                                 {
2106                                                   /* 33222222222211111111110000000000
2107                                                      10987654321098765432109876543210
2108                                                      001110001x0xxxxxxxxx10xxxxxxxxxx
2109                                                      ldtrsb.  */
2110                                                   return 915;
2111                                                 }
2112                                               else
2113                                                 {
2114                                                   /* 33222222222211111111110000000000
2115                                                      10987654321098765432109876543210
2116                                                      101110001x0xxxxxxxxx10xxxxxxxxxx
2117                                                      ldtrsw.  */
2118                                                   return 921;
2119                                                 }
2120                                             }
2121                                           else
2122                                             {
2123                                               /* 33222222222211111111110000000000
2124                                                  10987654321098765432109876543210
2125                                                  x11110001x0xxxxxxxxx10xxxxxxxxxx
2126                                                  ldtrsh.  */
2127                                               return 918;
2128                                             }
2129                                         }
2130                                     }
2131                                   else
2132                                     {
2133                                       if (((word >> 23) & 0x1) == 0)
2134                                         {
2135                                           if (((word >> 22) & 0x1) == 0)
2136                                             {
2137                                               if (((word >> 31) & 0x1) == 0)
2138                                                 {
2139                                                   if (((word >> 30) & 0x1) == 0)
2140                                                     {
2141                                                       /* 33222222222211111111110000000000
2142                                                          10987654321098765432109876543210
2143                                                          00111000001xxxxxxxxx10xxxxxxxxxx
2144                                                          strb.  */
2145                                                       return 901;
2146                                                     }
2147                                                   else
2148                                                     {
2149                                                       /* 33222222222211111111110000000000
2150                                                          10987654321098765432109876543210
2151                                                          01111000001xxxxxxxxx10xxxxxxxxxx
2152                                                          strh.  */
2153                                                       return 906;
2154                                                     }
2155                                                 }
2156                                               else
2157                                                 {
2158                                                   /* 33222222222211111111110000000000
2159                                                      10987654321098765432109876543210
2160                                                      1x111000001xxxxxxxxx10xxxxxxxxxx
2161                                                      str.  */
2162                                                   return 909;
2163                                                 }
2164                                             }
2165                                           else
2166                                             {
2167                                               if (((word >> 31) & 0x1) == 0)
2168                                                 {
2169                                                   if (((word >> 30) & 0x1) == 0)
2170                                                     {
2171                                                       /* 33222222222211111111110000000000
2172                                                          10987654321098765432109876543210
2173                                                          00111000011xxxxxxxxx10xxxxxxxxxx
2174                                                          ldrb.  */
2175                                                       return 902;
2176                                                     }
2177                                                   else
2178                                                     {
2179                                                       /* 33222222222211111111110000000000
2180                                                          10987654321098765432109876543210
2181                                                          01111000011xxxxxxxxx10xxxxxxxxxx
2182                                                          ldrh.  */
2183                                                       return 907;
2184                                                     }
2185                                                 }
2186                                               else
2187                                                 {
2188                                                   /* 33222222222211111111110000000000
2189                                                      10987654321098765432109876543210
2190                                                      1x111000011xxxxxxxxx10xxxxxxxxxx
2191                                                      ldr.  */
2192                                                   return 910;
2193                                                 }
2194                                             }
2195                                         }
2196                                       else
2197                                         {
2198                                           if (((word >> 30) & 0x1) == 0)
2199                                             {
2200                                               if (((word >> 31) & 0x1) == 0)
2201                                                 {
2202                                                   /* 33222222222211111111110000000000
2203                                                      10987654321098765432109876543210
2204                                                      001110001x1xxxxxxxxx10xxxxxxxxxx
2205                                                      ldrsb.  */
2206                                                   return 903;
2207                                                 }
2208                                               else
2209                                                 {
2210                                                   /* 33222222222211111111110000000000
2211                                                      10987654321098765432109876543210
2212                                                      101110001x1xxxxxxxxx10xxxxxxxxxx
2213                                                      ldrsw.  */
2214                                                   return 911;
2215                                                 }
2216                                             }
2217                                           else
2218                                             {
2219                                               if (((word >> 31) & 0x1) == 0)
2220                                                 {
2221                                                   /* 33222222222211111111110000000000
2222                                                      10987654321098765432109876543210
2223                                                      011110001x1xxxxxxxxx10xxxxxxxxxx
2224                                                      ldrsh.  */
2225                                                   return 908;
2226                                                 }
2227                                               else
2228                                                 {
2229                                                   /* 33222222222211111111110000000000
2230                                                      10987654321098765432109876543210
2231                                                      111110001x1xxxxxxxxx10xxxxxxxxxx
2232                                                      prfm.  */
2233                                                   return 912;
2234                                                 }
2235                                             }
2236                                         }
2237                                     }
2238                                 }
2239                             }
2240                           else
2241                             {
2242                               if (((word >> 21) & 0x1) == 0)
2243                                 {
2244                                   if (((word >> 23) & 0x1) == 0)
2245                                     {
2246                                       if (((word >> 22) & 0x1) == 0)
2247                                         {
2248                                           if (((word >> 31) & 0x1) == 0)
2249                                             {
2250                                               if (((word >> 30) & 0x1) == 0)
2251                                                 {
2252                                                   /* 33222222222211111111110000000000
2253                                                      10987654321098765432109876543210
2254                                                      00111000000xxxxxxxxxx1xxxxxxxxxx
2255                                                      strb.  */
2256                                                   return 870;
2257                                                 }
2258                                               else
2259                                                 {
2260                                                   /* 33222222222211111111110000000000
2261                                                      10987654321098765432109876543210
2262                                                      01111000000xxxxxxxxxx1xxxxxxxxxx
2263                                                      strh.  */
2264                                                   return 875;
2265                                                 }
2266                                             }
2267                                           else
2268                                             {
2269                                               /* 33222222222211111111110000000000
2270                                                  10987654321098765432109876543210
2271                                                  1x111000000xxxxxxxxxx1xxxxxxxxxx
2272                                                  str.  */
2273                                               return 878;
2274                                             }
2275                                         }
2276                                       else
2277                                         {
2278                                           if (((word >> 31) & 0x1) == 0)
2279                                             {
2280                                               if (((word >> 30) & 0x1) == 0)
2281                                                 {
2282                                                   /* 33222222222211111111110000000000
2283                                                      10987654321098765432109876543210
2284                                                      00111000010xxxxxxxxxx1xxxxxxxxxx
2285                                                      ldrb.  */
2286                                                   return 871;
2287                                                 }
2288                                               else
2289                                                 {
2290                                                   /* 33222222222211111111110000000000
2291                                                      10987654321098765432109876543210
2292                                                      01111000010xxxxxxxxxx1xxxxxxxxxx
2293                                                      ldrh.  */
2294                                                   return 876;
2295                                                 }
2296                                             }
2297                                           else
2298                                             {
2299                                               /* 33222222222211111111110000000000
2300                                                  10987654321098765432109876543210
2301                                                  1x111000010xxxxxxxxxx1xxxxxxxxxx
2302                                                  ldr.  */
2303                                               return 879;
2304                                             }
2305                                         }
2306                                     }
2307                                   else
2308                                     {
2309                                       if (((word >> 30) & 0x1) == 0)
2310                                         {
2311                                           if (((word >> 31) & 0x1) == 0)
2312                                             {
2313                                               /* 33222222222211111111110000000000
2314                                                  10987654321098765432109876543210
2315                                                  001110001x0xxxxxxxxxx1xxxxxxxxxx
2316                                                  ldrsb.  */
2317                                               return 872;
2318                                             }
2319                                           else
2320                                             {
2321                                               /* 33222222222211111111110000000000
2322                                                  10987654321098765432109876543210
2323                                                  101110001x0xxxxxxxxxx1xxxxxxxxxx
2324                                                  ldrsw.  */
2325                                               return 880;
2326                                             }
2327                                         }
2328                                       else
2329                                         {
2330                                           /* 33222222222211111111110000000000
2331                                              10987654321098765432109876543210
2332                                              x11110001x0xxxxxxxxxx1xxxxxxxxxx
2333                                              ldrsh.  */
2334                                           return 877;
2335                                         }
2336                                     }
2337                                 }
2338                               else
2339                                 {
2340                                   if (((word >> 23) & 0x1) == 0)
2341                                     {
2342                                       /* 33222222222211111111110000000000
2343                                          10987654321098765432109876543210
2344                                          xx1110000x1xxxxxxxxxx1xxxxxxxxxx
2345                                          ldraa.  */
2346                                       return 935;
2347                                     }
2348                                   else
2349                                     {
2350                                       /* 33222222222211111111110000000000
2351                                          10987654321098765432109876543210
2352                                          xx1110001x1xxxxxxxxxx1xxxxxxxxxx
2353                                          ldrab.  */
2354                                       return 936;
2355                                     }
2356                                 }
2357                             }
2358                         }
2359                     }
2360                   else
2361                     {
2362                       if (((word >> 23) & 0x1) == 0)
2363                         {
2364                           if (((word >> 22) & 0x1) == 0)
2365                             {
2366                               if (((word >> 29) & 0x1) == 0)
2367                                 {
2368                                   if (((word >> 10) & 0x1) == 0)
2369                                     {
2370                                       if (((word >> 11) & 0x1) == 0)
2371                                         {
2372                                           if (((word >> 21) & 0x1) == 0)
2373                                             {
2374                                               if (((word >> 30) & 0x1) == 0)
2375                                                 {
2376                                                   if (((word >> 31) & 0x1) == 0)
2377                                                     {
2378                                                       /* 33222222222211111111110000000000
2379                                                          10987654321098765432109876543210
2380                                                          00011001000xxxxxxxxx00xxxxxxxxxx
2381                                                          stlurb.  */
2382                                                       return 2381;
2383                                                     }
2384                                                   else
2385                                                     {
2386                                                       /* 33222222222211111111110000000000
2387                                                          10987654321098765432109876543210
2388                                                          10011001000xxxxxxxxx00xxxxxxxxxx
2389                                                          stlur.  */
2390                                                       return 2389;
2391                                                     }
2392                                                 }
2393                                               else
2394                                                 {
2395                                                   if (((word >> 31) & 0x1) == 0)
2396                                                     {
2397                                                       /* 33222222222211111111110000000000
2398                                                          10987654321098765432109876543210
2399                                                          01011001000xxxxxxxxx00xxxxxxxxxx
2400                                                          stlurh.  */
2401                                                       return 2385;
2402                                                     }
2403                                                   else
2404                                                     {
2405                                                       /* 33222222222211111111110000000000
2406                                                          10987654321098765432109876543210
2407                                                          11011001000xxxxxxxxx00xxxxxxxxxx
2408                                                          stlur.  */
2409                                                       return 2392;
2410                                                     }
2411                                                 }
2412                                             }
2413                                           else
2414                                             {
2415                                               /* 33222222222211111111110000000000
2416                                                  10987654321098765432109876543210
2417                                                  xx011001001xxxxxxxxx00xxxxxxxxxx
2418                                                  stzgm.  */
2419                                               return 964;
2420                                             }
2421                                         }
2422                                       else
2423                                         {
2424                                           /* 33222222222211111111110000000000
2425                                              10987654321098765432109876543210
2426                                              xx01100100xxxxxxxxxx10xxxxxxxxxx
2427                                              stg.  */
2428                                           return 881;
2429                                         }
2430                                     }
2431                                   else
2432                                     {
2433                                       /* 33222222222211111111110000000000
2434                                          10987654321098765432109876543210
2435                                          xx01100100xxxxxxxxxxx1xxxxxxxxxx
2436                                          stg.  */
2437                                       return 885;
2438                                     }
2439                                 }
2440                               else
2441                                 {
2442                                   if (((word >> 31) & 0x1) == 0)
2443                                     {
2444                                       if (((word >> 30) & 0x1) == 0)
2445                                         {
2446                                           /* 33222222222211111111110000000000
2447                                              10987654321098765432109876543210
2448                                              0011100100xxxxxxxxxxxxxxxxxxxxxx
2449                                              strb.  */
2450                                           return 889;
2451                                         }
2452                                       else
2453                                         {
2454                                           /* 33222222222211111111110000000000
2455                                              10987654321098765432109876543210
2456                                              0111100100xxxxxxxxxxxxxxxxxxxxxx
2457                                              strh.  */
2458                                           return 894;
2459                                         }
2460                                     }
2461                                   else
2462                                     {
2463                                       /* 33222222222211111111110000000000
2464                                          10987654321098765432109876543210
2465                                          1x11100100xxxxxxxxxxxxxxxxxxxxxx
2466                                          str.  */
2467                                       return 897;
2468                                     }
2469                                 }
2470                             }
2471                           else
2472                             {
2473                               if (((word >> 29) & 0x1) == 0)
2474                                 {
2475                                   if (((word >> 10) & 0x1) == 0)
2476                                     {
2477                                       if (((word >> 11) & 0x1) == 0)
2478                                         {
2479                                           if (((word >> 21) & 0x1) == 0)
2480                                             {
2481                                               if (((word >> 30) & 0x1) == 0)
2482                                                 {
2483                                                   if (((word >> 31) & 0x1) == 0)
2484                                                     {
2485                                                       /* 33222222222211111111110000000000
2486                                                          10987654321098765432109876543210
2487                                                          00011001010xxxxxxxxx00xxxxxxxxxx
2488                                                          ldapurb.  */
2489                                                       return 2382;
2490                                                     }
2491                                                   else
2492                                                     {
2493                                                       /* 33222222222211111111110000000000
2494                                                          10987654321098765432109876543210
2495                                                          10011001010xxxxxxxxx00xxxxxxxxxx
2496                                                          ldapur.  */
2497                                                       return 2390;
2498                                                     }
2499                                                 }
2500                                               else
2501                                                 {
2502                                                   if (((word >> 31) & 0x1) == 0)
2503                                                     {
2504                                                       /* 33222222222211111111110000000000
2505                                                          10987654321098765432109876543210
2506                                                          01011001010xxxxxxxxx00xxxxxxxxxx
2507                                                          ldapurh.  */
2508                                                       return 2386;
2509                                                     }
2510                                                   else
2511                                                     {
2512                                                       /* 33222222222211111111110000000000
2513                                                          10987654321098765432109876543210
2514                                                          11011001010xxxxxxxxx00xxxxxxxxxx
2515                                                          ldapur.  */
2516                                                       return 2393;
2517                                                     }
2518                                                 }
2519                                             }
2520                                           else
2521                                             {
2522                                               /* 33222222222211111111110000000000
2523                                                  10987654321098765432109876543210
2524                                                  xx011001011xxxxxxxxx00xxxxxxxxxx
2525                                                  ldg.  */
2526                                               return 934;
2527                                             }
2528                                         }
2529                                       else
2530                                         {
2531                                           /* 33222222222211111111110000000000
2532                                              10987654321098765432109876543210
2533                                              xx01100101xxxxxxxxxx10xxxxxxxxxx
2534                                              stzg.  */
2535                                           return 882;
2536                                         }
2537                                     }
2538                                   else
2539                                     {
2540                                       /* 33222222222211111111110000000000
2541                                          10987654321098765432109876543210
2542                                          xx01100101xxxxxxxxxxx1xxxxxxxxxx
2543                                          stzg.  */
2544                                       return 886;
2545                                     }
2546                                 }
2547                               else
2548                                 {
2549                                   if (((word >> 31) & 0x1) == 0)
2550                                     {
2551                                       if (((word >> 30) & 0x1) == 0)
2552                                         {
2553                                           /* 33222222222211111111110000000000
2554                                              10987654321098765432109876543210
2555                                              0011100101xxxxxxxxxxxxxxxxxxxxxx
2556                                              ldrb.  */
2557                                           return 890;
2558                                         }
2559                                       else
2560                                         {
2561                                           /* 33222222222211111111110000000000
2562                                              10987654321098765432109876543210
2563                                              0111100101xxxxxxxxxxxxxxxxxxxxxx
2564                                              ldrh.  */
2565                                           return 895;
2566                                         }
2567                                     }
2568                                   else
2569                                     {
2570                                       /* 33222222222211111111110000000000
2571                                          10987654321098765432109876543210
2572                                          1x11100101xxxxxxxxxxxxxxxxxxxxxx
2573                                          ldr.  */
2574                                       return 898;
2575                                     }
2576                                 }
2577                             }
2578                         }
2579                       else
2580                         {
2581                           if (((word >> 29) & 0x1) == 0)
2582                             {
2583                               if (((word >> 10) & 0x1) == 0)
2584                                 {
2585                                   if (((word >> 11) & 0x1) == 0)
2586                                     {
2587                                       if (((word >> 21) & 0x1) == 0)
2588                                         {
2589                                           if (((word >> 22) & 0x1) == 0)
2590                                             {
2591                                               if (((word >> 30) & 0x1) == 0)
2592                                                 {
2593                                                   if (((word >> 31) & 0x1) == 0)
2594                                                     {
2595                                                       /* 33222222222211111111110000000000
2596                                                          10987654321098765432109876543210
2597                                                          00011001100xxxxxxxxx00xxxxxxxxxx
2598                                                          ldapursb.  */
2599                                                       return 2384;
2600                                                     }
2601                                                   else
2602                                                     {
2603                                                       /* 33222222222211111111110000000000
2604                                                          10987654321098765432109876543210
2605                                                          10011001100xxxxxxxxx00xxxxxxxxxx
2606                                                          ldapursw.  */
2607                                                       return 2391;
2608                                                     }
2609                                                 }
2610                                               else
2611                                                 {
2612                                                   /* 33222222222211111111110000000000
2613                                                      10987654321098765432109876543210
2614                                                      x1011001100xxxxxxxxx00xxxxxxxxxx
2615                                                      ldapursh.  */
2616                                                   return 2388;
2617                                                 }
2618                                             }
2619                                           else
2620                                             {
2621                                               if (((word >> 30) & 0x1) == 0)
2622                                                 {
2623                                                   /* 33222222222211111111110000000000
2624                                                      10987654321098765432109876543210
2625                                                      x0011001110xxxxxxxxx00xxxxxxxxxx
2626                                                      ldapursb.  */
2627                                                   return 2383;
2628                                                 }
2629                                               else
2630                                                 {
2631                                                   /* 33222222222211111111110000000000
2632                                                      10987654321098765432109876543210
2633                                                      x1011001110xxxxxxxxx00xxxxxxxxxx
2634                                                      ldapursh.  */
2635                                                   return 2387;
2636                                                 }
2637                                             }
2638                                         }
2639                                       else
2640                                         {
2641                                           if (((word >> 22) & 0x1) == 0)
2642                                             {
2643                                               /* 33222222222211111111110000000000
2644                                                  10987654321098765432109876543210
2645                                                  xx011001101xxxxxxxxx00xxxxxxxxxx
2646                                                  stgm.  */
2647                                               return 963;
2648                                             }
2649                                           else
2650                                             {
2651                                               /* 33222222222211111111110000000000
2652                                                  10987654321098765432109876543210
2653                                                  xx011001111xxxxxxxxx00xxxxxxxxxx
2654                                                  ldgm.  */
2655                                               return 962;
2656                                             }
2657                                         }
2658                                     }
2659                                   else
2660                                     {
2661                                       if (((word >> 22) & 0x1) == 0)
2662                                         {
2663                                           /* 33222222222211111111110000000000
2664                                              10987654321098765432109876543210
2665                                              xx01100110xxxxxxxxxx10xxxxxxxxxx
2666                                              st2g.  */
2667                                           return 883;
2668                                         }
2669                                       else
2670                                         {
2671                                           /* 33222222222211111111110000000000
2672                                              10987654321098765432109876543210
2673                                              xx01100111xxxxxxxxxx10xxxxxxxxxx
2674                                              stz2g.  */
2675                                           return 884;
2676                                         }
2677                                     }
2678                                 }
2679                               else
2680                                 {
2681                                   if (((word >> 22) & 0x1) == 0)
2682                                     {
2683                                       /* 33222222222211111111110000000000
2684                                          10987654321098765432109876543210
2685                                          xx01100110xxxxxxxxxxx1xxxxxxxxxx
2686                                          st2g.  */
2687                                       return 887;
2688                                     }
2689                                   else
2690                                     {
2691                                       /* 33222222222211111111110000000000
2692                                          10987654321098765432109876543210
2693                                          xx01100111xxxxxxxxxxx1xxxxxxxxxx
2694                                          stz2g.  */
2695                                       return 888;
2696                                     }
2697                                 }
2698                             }
2699                           else
2700                             {
2701                               if (((word >> 30) & 0x1) == 0)
2702                                 {
2703                                   if (((word >> 31) & 0x1) == 0)
2704                                     {
2705                                       /* 33222222222211111111110000000000
2706                                          10987654321098765432109876543210
2707                                          001110011xxxxxxxxxxxxxxxxxxxxxxx
2708                                          ldrsb.  */
2709                                       return 891;
2710                                     }
2711                                   else
2712                                     {
2713                                       /* 33222222222211111111110000000000
2714                                          10987654321098765432109876543210
2715                                          101110011xxxxxxxxxxxxxxxxxxxxxxx
2716                                          ldrsw.  */
2717                                       return 899;
2718                                     }
2719                                 }
2720                               else
2721                                 {
2722                                   if (((word >> 31) & 0x1) == 0)
2723                                     {
2724                                       /* 33222222222211111111110000000000
2725                                          10987654321098765432109876543210
2726                                          011110011xxxxxxxxxxxxxxxxxxxxxxx
2727                                          ldrsh.  */
2728                                       return 896;
2729                                     }
2730                                   else
2731                                     {
2732                                       /* 33222222222211111111110000000000
2733                                          10987654321098765432109876543210
2734                                          111110011xxxxxxxxxxxxxxxxxxxxxxx
2735                                          prfm.  */
2736                                       return 900;
2737                                     }
2738                                 }
2739                             }
2740                         }
2741                     }
2742                 }
2743             }
2744         }
2745       else
2746         {
2747           if (((word >> 24) & 0x1) == 0)
2748             {
2749               if (((word >> 27) & 0x1) == 0)
2750                 {
2751                   if (((word >> 23) & 0x1) == 0)
2752                     {
2753                       if (((word >> 29) & 0x1) == 0)
2754                         {
2755                           if (((word >> 30) & 0x1) == 0)
2756                             {
2757                               /* 33222222222211111111110000000000
2758                                  10987654321098765432109876543210
2759                                  x00x00100xxxxxxxxxxxxxxxxxxxxxxx
2760                                  and.  */
2761                               return 991;
2762                             }
2763                           else
2764                             {
2765                               /* 33222222222211111111110000000000
2766                                  10987654321098765432109876543210
2767                                  x10x00100xxxxxxxxxxxxxxxxxxxxxxx
2768                                  eor.  */
2769                               return 995;
2770                             }
2771                         }
2772                       else
2773                         {
2774                           if (((word >> 30) & 0x1) == 0)
2775                             {
2776                               /* 33222222222211111111110000000000
2777                                  10987654321098765432109876543210
2778                                  x01x00100xxxxxxxxxxxxxxxxxxxxxxx
2779                                  orr.  */
2780                               return 993;
2781                             }
2782                           else
2783                             {
2784                               /* 33222222222211111111110000000000
2785                                  10987654321098765432109876543210
2786                                  x11x00100xxxxxxxxxxxxxxxxxxxxxxx
2787                                  ands.  */
2788                               return 996;
2789                             }
2790                         }
2791                     }
2792                   else
2793                     {
2794                       if (((word >> 29) & 0x1) == 0)
2795                         {
2796                           if (((word >> 30) & 0x1) == 0)
2797                             {
2798                               /* 33222222222211111111110000000000
2799                                  10987654321098765432109876543210
2800                                  x00x00101xxxxxxxxxxxxxxxxxxxxxxx
2801                                  movn.  */
2802                               return 1182;
2803                             }
2804                           else
2805                             {
2806                               /* 33222222222211111111110000000000
2807                                  10987654321098765432109876543210
2808                                  x10x00101xxxxxxxxxxxxxxxxxxxxxxx
2809                                  movz.  */
2810                               return 1184;
2811                             }
2812                         }
2813                       else
2814                         {
2815                           /* 33222222222211111111110000000000
2816                              10987654321098765432109876543210
2817                              xx1x00101xxxxxxxxxxxxxxxxxxxxxxx
2818                              movk.  */
2819                           return 1186;
2820                         }
2821                     }
2822                 }
2823               else
2824                 {
2825                   if (((word >> 21) & 0x1) == 0)
2826                     {
2827                       if (((word >> 28) & 0x1) == 0)
2828                         {
2829                           if (((word >> 29) & 0x1) == 0)
2830                             {
2831                               if (((word >> 30) & 0x1) == 0)
2832                                 {
2833                                   /* 33222222222211111111110000000000
2834                                      10987654321098765432109876543210
2835                                      x0001010xx0xxxxxxxxxxxxxxxxxxxxx
2836                                      and.  */
2837                                   return 998;
2838                                 }
2839                               else
2840                                 {
2841                                   /* 33222222222211111111110000000000
2842                                      10987654321098765432109876543210
2843                                      x1001010xx0xxxxxxxxxxxxxxxxxxxxx
2844                                      eor.  */
2845                                   return 1005;
2846                                 }
2847                             }
2848                           else
2849                             {
2850                               if (((word >> 30) & 0x1) == 0)
2851                                 {
2852                                   /* 33222222222211111111110000000000
2853                                      10987654321098765432109876543210
2854                                      x0101010xx0xxxxxxxxxxxxxxxxxxxxx
2855                                      orr.  */
2856                                   return 1000;
2857                                 }
2858                               else
2859                                 {
2860                                   /* 33222222222211111111110000000000
2861                                      10987654321098765432109876543210
2862                                      x1101010xx0xxxxxxxxxxxxxxxxxxxxx
2863                                      ands.  */
2864                                   return 1007;
2865                                 }
2866                             }
2867                         }
2868                       else
2869                         {
2870                           if (((word >> 10) & 0x1) == 0)
2871                             {
2872                               if (((word >> 11) & 0x1) == 0)
2873                                 {
2874                                   if (((word >> 22) & 0x1) == 0)
2875                                     {
2876                                       if (((word >> 23) & 0x1) == 0)
2877                                         {
2878                                           if (((word >> 29) & 0x1) == 0)
2879                                             {
2880                                               if (((word >> 30) & 0x1) == 0)
2881                                                 {
2882                                                   /* 33222222222211111111110000000000
2883                                                      10987654321098765432109876543210
2884                                                      x0011010000xxxxxxxxx00xxxxxxxxxx
2885                                                      adc.  */
2886                                                   return 0;
2887                                                 }
2888                                               else
2889                                                 {
2890                                                   /* 33222222222211111111110000000000
2891                                                      10987654321098765432109876543210
2892                                                      x1011010000xxxxxxxxx00xxxxxxxxxx
2893                                                      sbc.  */
2894                                                   return 2;
2895                                                 }
2896                                             }
2897                                           else
2898                                             {
2899                                               if (((word >> 30) & 0x1) == 0)
2900                                                 {
2901                                                   /* 33222222222211111111110000000000
2902                                                      10987654321098765432109876543210
2903                                                      x0111010000xxxxxxxxx00xxxxxxxxxx
2904                                                      adcs.  */
2905                                                   return 1;
2906                                                 }
2907                                               else
2908                                                 {
2909                                                   /* 33222222222211111111110000000000
2910                                                      10987654321098765432109876543210
2911                                                      x1111010000xxxxxxxxx00xxxxxxxxxx
2912                                                      sbcs.  */
2913                                                   return 4;
2914                                                 }
2915                                             }
2916                                         }
2917                                       else
2918                                         {
2919                                           if (((word >> 30) & 0x1) == 0)
2920                                             {
2921                                               /* 33222222222211111111110000000000
2922                                                  10987654321098765432109876543210
2923                                                  x0x11010100xxxxxxxxx00xxxxxxxxxx
2924                                                  csel.  */
2925                                               return 662;
2926                                             }
2927                                           else
2928                                             {
2929                                               /* 33222222222211111111110000000000
2930                                                  10987654321098765432109876543210
2931                                                  x1x11010100xxxxxxxxx00xxxxxxxxxx
2932                                                  csinv.  */
2933                                               return 666;
2934                                             }
2935                                         }
2936                                     }
2937                                   else
2938                                     {
2939                                       if (((word >> 23) & 0x1) == 0)
2940                                         {
2941                                           if (((word >> 30) & 0x1) == 0)
2942                                             {
2943                                               /* 33222222222211111111110000000000
2944                                                  10987654321098765432109876543210
2945                                                  x0x11010010xxxxxxxxx00xxxxxxxxxx
2946                                                  ccmn.  */
2947                                               return 660;
2948                                             }
2949                                           else
2950                                             {
2951                                               /* 33222222222211111111110000000000
2952                                                  10987654321098765432109876543210
2953                                                  x1x11010010xxxxxxxxx00xxxxxxxxxx
2954                                                  ccmp.  */
2955                                               return 661;
2956                                             }
2957                                         }
2958                                       else
2959                                         {
2960                                           if (((word >> 12) & 0x1) == 0)
2961                                             {
2962                                               if (((word >> 13) & 0x1) == 0)
2963                                                 {
2964                                                   if (((word >> 14) & 0x1) == 0)
2965                                                     {
2966                                                       if (((word >> 29) & 0x1) == 0)
2967                                                         {
2968                                                           if (((word >> 30) & 0x1) == 0)
2969                                                             {
2970                                                               /* 33222222222211111111110000000000
2971                                                                  10987654321098765432109876543210
2972                                                                  x0011010110xxxxxx00000xxxxxxxxxx
2973                                                                  subp.  */
2974                                                               return 721;
2975                                                             }
2976                                                           else
2977                                                             {
2978                                                               if (((word >> 16) & 0x1) == 0)
2979                                                                 {
2980                                                                   /* 33222222222211111111110000000000
2981                                                                      10987654321098765432109876543210
2982                                                                      x1011010110xxxx0x00000xxxxxxxxxx
2983                                                                      rbit.  */
2984                                                                   return 685;
2985                                                                 }
2986                                                               else
2987                                                                 {
2988                                                                   /* 33222222222211111111110000000000
2989                                                                      10987654321098765432109876543210
2990                                                                      x1011010110xxxx1x00000xxxxxxxxxx
2991                                                                      pacia.  */
2992                                                                   return 693;
2993                                                                 }
2994                                                             }
2995                                                         }
2996                                                       else
2997                                                         {
2998                                                           /* 33222222222211111111110000000000
2999                                                              10987654321098765432109876543210
3000                                                              xx111010110xxxxxx00000xxxxxxxxxx
3001                                                              subps.  */
3002                                                           return 722;
3003                                                         }
3004                                                     }
3005                                                   else
3006                                                     {
3007                                                       if (((word >> 30) & 0x1) == 0)
3008                                                         {
3009                                                           /* 33222222222211111111110000000000
3010                                                              10987654321098765432109876543210
3011                                                              x0x11010110xxxxxx10000xxxxxxxxxx
3012                                                              crc32b.  */
3013                                                           return 727;
3014                                                         }
3015                                                       else
3016                                                         {
3017                                                           /* 33222222222211111111110000000000
3018                                                              10987654321098765432109876543210
3019                                                              x1x11010110xxxxxx10000xxxxxxxxxx
3020                                                              xpaci.  */
3021                                                           return 709;
3022                                                         }
3023                                                     }
3024                                                 }
3025                                               else
3026                                                 {
3027                                                   if (((word >> 30) & 0x1) == 0)
3028                                                     {
3029                                                       /* 33222222222211111111110000000000
3030                                                          10987654321098765432109876543210
3031                                                          x0x11010110xxxxxxx1000xxxxxxxxxx
3032                                                          lslv.  */
3033                                                       return 713;
3034                                                     }
3035                                                   else
3036                                                     {
3037                                                       /* 33222222222211111111110000000000
3038                                                          10987654321098765432109876543210
3039                                                          x1x11010110xxxxxxx1000xxxxxxxxxx
3040                                                          paciza.  */
3041                                                       return 701;
3042                                                     }
3043                                                 }
3044                                             }
3045                                           else
3046                                             {
3047                                               if (((word >> 13) & 0x1) == 0)
3048                                                 {
3049                                                   if (((word >> 14) & 0x1) == 0)
3050                                                     {
3051                                                       if (((word >> 30) & 0x1) == 0)
3052                                                         {
3053                                                           /* 33222222222211111111110000000000
3054                                                              10987654321098765432109876543210
3055                                                              x0x11010110xxxxxx00100xxxxxxxxxx
3056                                                              irg.  */
3057                                                           return 724;
3058                                                         }
3059                                                       else
3060                                                         {
3061                                                           if (((word >> 16) & 0x1) == 0)
3062                                                             {
3063                                                               /* 33222222222211111111110000000000
3064                                                                  10987654321098765432109876543210
3065                                                                  x1x11010110xxxx0x00100xxxxxxxxxx
3066                                                                  clz.  */
3067                                                               return 690;
3068                                                             }
3069                                                           else
3070                                                             {
3071                                                               /* 33222222222211111111110000000000
3072                                                                  10987654321098765432109876543210
3073                                                                  x1x11010110xxxx1x00100xxxxxxxxxx
3074                                                                  autia.  */
3075                                                               return 697;
3076                                                             }
3077                                                         }
3078                                                     }
3079                                                   else
3080                                                     {
3081                                                       /* 33222222222211111111110000000000
3082                                                          10987654321098765432109876543210
3083                                                          xxx11010110xxxxxx10100xxxxxxxxxx
3084                                                          crc32cb.  */
3085                                                       return 731;
3086                                                     }
3087                                                 }
3088                                               else
3089                                                 {
3090                                                   if (((word >> 30) & 0x1) == 0)
3091                                                     {
3092                                                       /* 33222222222211111111110000000000
3093                                                          10987654321098765432109876543210
3094                                                          x0x11010110xxxxxxx1100xxxxxxxxxx
3095                                                          pacga.  */
3096                                                       return 726;
3097                                                     }
3098                                                   else
3099                                                     {
3100                                                       /* 33222222222211111111110000000000
3101                                                          10987654321098765432109876543210
3102                                                          x1x11010110xxxxxxx1100xxxxxxxxxx
3103                                                          autiza.  */
3104                                                       return 705;
3105                                                     }
3106                                                 }
3107                                             }
3108                                         }
3109                                     }
3110                                 }
3111                               else
3112                                 {
3113                                   if (((word >> 22) & 0x1) == 0)
3114                                     {
3115                                       if (((word >> 14) & 0x1) == 0)
3116                                         {
3117                                           /* 33222222222211111111110000000000
3118                                              10987654321098765432109876543210
3119                                              xxx11010x00xxxxxx0xx10xxxxxxxxxx
3120                                              setf8.  */
3121                                           return 2379;
3122                                         }
3123                                       else
3124                                         {
3125                                           /* 33222222222211111111110000000000
3126                                              10987654321098765432109876543210
3127                                              xxx11010x00xxxxxx1xx10xxxxxxxxxx
3128                                              setf16.  */
3129                                           return 2380;
3130                                         }
3131                                     }
3132                                   else
3133                                     {
3134                                       if (((word >> 23) & 0x1) == 0)
3135                                         {
3136                                           if (((word >> 30) & 0x1) == 0)
3137                                             {
3138                                               /* 33222222222211111111110000000000
3139                                                  10987654321098765432109876543210
3140                                                  x0x11010010xxxxxxxxx10xxxxxxxxxx
3141                                                  ccmn.  */
3142                                               return 658;
3143                                             }
3144                                           else
3145                                             {
3146                                               /* 33222222222211111111110000000000
3147                                                  10987654321098765432109876543210
3148                                                  x1x11010010xxxxxxxxx10xxxxxxxxxx
3149                                                  ccmp.  */
3150                                               return 659;
3151                                             }
3152                                         }
3153                                       else
3154                                         {
3155                                           if (((word >> 12) & 0x1) == 0)
3156                                             {
3157                                               if (((word >> 13) & 0x1) == 0)
3158                                                 {
3159                                                   if (((word >> 14) & 0x1) == 0)
3160                                                     {
3161                                                       if (((word >> 30) & 0x1) == 0)
3162                                                         {
3163                                                           /* 33222222222211111111110000000000
3164                                                              10987654321098765432109876543210
3165                                                              x0x11010110xxxxxx00010xxxxxxxxxx
3166                                                              udiv.  */
3167                                                           return 711;
3168                                                         }
3169                                                       else
3170                                                         {
3171                                                           if (((word >> 16) & 0x1) == 0)
3172                                                             {
3173                                                               if (((word >> 31) & 0x1) == 0)
3174                                                                 {
3175                                                                   /* 33222222222211111111110000000000
3176                                                                      10987654321098765432109876543210
3177                                                                      01x11010110xxxx0x00010xxxxxxxxxx
3178                                                                      rev.  */
3179                                                                   return 687;
3180                                                                 }
3181                                                               else
3182                                                                 {
3183                                                                   /* 33222222222211111111110000000000
3184                                                                      10987654321098765432109876543210
3185                                                                      11x11010110xxxx0x00010xxxxxxxxxx
3186                                                                      rev32.  */
3187                                                                   return 692;
3188                                                                 }
3189                                                             }
3190                                                           else
3191                                                             {
3192                                                               /* 33222222222211111111110000000000
3193                                                                  10987654321098765432109876543210
3194                                                                  x1x11010110xxxx1x00010xxxxxxxxxx
3195                                                                  pacda.  */
3196                                                               return 695;
3197                                                             }
3198                                                         }
3199                                                     }
3200                                                   else
3201                                                     {
3202                                                       /* 33222222222211111111110000000000
3203                                                          10987654321098765432109876543210
3204                                                          xxx11010110xxxxxx10010xxxxxxxxxx
3205                                                          crc32w.  */
3206                                                       return 729;
3207                                                     }
3208                                                 }
3209                                               else
3210                                                 {
3211                                                   if (((word >> 30) & 0x1) == 0)
3212                                                     {
3213                                                       /* 33222222222211111111110000000000
3214                                                          10987654321098765432109876543210
3215                                                          x0x11010110xxxxxxx1010xxxxxxxxxx
3216                                                          asrv.  */
3217                                                       return 717;
3218                                                     }
3219                                                   else
3220                                                     {
3221                                                       /* 33222222222211111111110000000000
3222                                                          10987654321098765432109876543210
3223                                                          x1x11010110xxxxxxx1010xxxxxxxxxx
3224                                                          pacdza.  */
3225                                                       return 703;
3226                                                     }
3227                                                 }
3228                                             }
3229                                           else
3230                                             {
3231                                               if (((word >> 13) & 0x1) == 0)
3232                                                 {
3233                                                   if (((word >> 14) & 0x1) == 0)
3234                                                     {
3235                                                       /* 33222222222211111111110000000000
3236                                                          10987654321098765432109876543210
3237                                                          xxx11010110xxxxxx00110xxxxxxxxxx
3238                                                          autda.  */
3239                                                       return 699;
3240                                                     }
3241                                                   else
3242                                                     {
3243                                                       /* 33222222222211111111110000000000
3244                                                          10987654321098765432109876543210
3245                                                          xxx11010110xxxxxx10110xxxxxxxxxx
3246                                                          crc32cw.  */
3247                                                       return 733;
3248                                                     }
3249                                                 }
3250                                               else
3251                                                 {
3252                                                   /* 33222222222211111111110000000000
3253                                                      10987654321098765432109876543210
3254                                                      xxx11010110xxxxxxx1110xxxxxxxxxx
3255                                                      autdza.  */
3256                                                   return 707;
3257                                                 }
3258                                             }
3259                                         }
3260                                     }
3261                                 }
3262                             }
3263                           else
3264                             {
3265                               if (((word >> 11) & 0x1) == 0)
3266                                 {
3267                                   if (((word >> 22) & 0x1) == 0)
3268                                     {
3269                                       if (((word >> 23) & 0x1) == 0)
3270                                         {
3271                                           /* 33222222222211111111110000000000
3272                                              10987654321098765432109876543210
3273                                              xxx11010000xxxxxxxxx01xxxxxxxxxx
3274                                              rmif.  */
3275                                           return 2378;
3276                                         }
3277                                       else
3278                                         {
3279                                           if (((word >> 30) & 0x1) == 0)
3280                                             {
3281                                               /* 33222222222211111111110000000000
3282                                                  10987654321098765432109876543210
3283                                                  x0x11010100xxxxxxxxx01xxxxxxxxxx
3284                                                  csinc.  */
3285                                               return 663;
3286                                             }
3287                                           else
3288                                             {
3289                                               /* 33222222222211111111110000000000
3290                                                  10987654321098765432109876543210
3291                                                  x1x11010100xxxxxxxxx01xxxxxxxxxx
3292                                                  csneg.  */
3293                                               return 669;
3294                                             }
3295                                         }
3296                                     }
3297                                   else
3298                                     {
3299                                       if (((word >> 12) & 0x1) == 0)
3300                                         {
3301                                           if (((word >> 13) & 0x1) == 0)
3302                                             {
3303                                               if (((word >> 14) & 0x1) == 0)
3304                                                 {
3305                                                   if (((word >> 16) & 0x1) == 0)
3306                                                     {
3307                                                       /* 33222222222211111111110000000000
3308                                                          10987654321098765432109876543210
3309                                                          xxx11010x10xxxx0x00001xxxxxxxxxx
3310                                                          rev16.  */
3311                                                       return 686;
3312                                                     }
3313                                                   else
3314                                                     {
3315                                                       /* 33222222222211111111110000000000
3316                                                          10987654321098765432109876543210
3317                                                          xxx11010x10xxxx1x00001xxxxxxxxxx
3318                                                          pacib.  */
3319                                                       return 694;
3320                                                     }
3321                                                 }
3322                                               else
3323                                                 {
3324                                                   if (((word >> 30) & 0x1) == 0)
3325                                                     {
3326                                                       /* 33222222222211111111110000000000
3327                                                          10987654321098765432109876543210
3328                                                          x0x11010x10xxxxxx10001xxxxxxxxxx
3329                                                          crc32h.  */
3330                                                       return 728;
3331                                                     }
3332                                                   else
3333                                                     {
3334                                                       /* 33222222222211111111110000000000
3335                                                          10987654321098765432109876543210
3336                                                          x1x11010x10xxxxxx10001xxxxxxxxxx
3337                                                          xpacd.  */
3338                                                       return 710;
3339                                                     }
3340                                                 }
3341                                             }
3342                                           else
3343                                             {
3344                                               if (((word >> 30) & 0x1) == 0)
3345                                                 {
3346                                                   /* 33222222222211111111110000000000
3347                                                      10987654321098765432109876543210
3348                                                      x0x11010x10xxxxxxx1001xxxxxxxxxx
3349                                                      lsrv.  */
3350                                                   return 715;
3351                                                 }
3352                                               else
3353                                                 {
3354                                                   /* 33222222222211111111110000000000
3355                                                      10987654321098765432109876543210
3356                                                      x1x11010x10xxxxxxx1001xxxxxxxxxx
3357                                                      pacizb.  */
3358                                                   return 702;
3359                                                 }
3360                                             }
3361                                         }
3362                                       else
3363                                         {
3364                                           if (((word >> 13) & 0x1) == 0)
3365                                             {
3366                                               if (((word >> 14) & 0x1) == 0)
3367                                                 {
3368                                                   if (((word >> 30) & 0x1) == 0)
3369                                                     {
3370                                                       /* 33222222222211111111110000000000
3371                                                          10987654321098765432109876543210
3372                                                          x0x11010x10xxxxxx00101xxxxxxxxxx
3373                                                          gmi.  */
3374                                                       return 725;
3375                                                     }
3376                                                   else
3377                                                     {
3378                                                       if (((word >> 16) & 0x1) == 0)
3379                                                         {
3380                                                           /* 33222222222211111111110000000000
3381                                                              10987654321098765432109876543210
3382                                                              x1x11010x10xxxx0x00101xxxxxxxxxx
3383                                                              cls.  */
3384                                                           return 691;
3385                                                         }
3386                                                       else
3387                                                         {
3388                                                           /* 33222222222211111111110000000000
3389                                                              10987654321098765432109876543210
3390                                                              x1x11010x10xxxx1x00101xxxxxxxxxx
3391                                                              autib.  */
3392                                                           return 698;
3393                                                         }
3394                                                     }
3395                                                 }
3396                                               else
3397                                                 {
3398                                                   /* 33222222222211111111110000000000
3399                                                      10987654321098765432109876543210
3400                                                      xxx11010x10xxxxxx10101xxxxxxxxxx
3401                                                      crc32ch.  */
3402                                                   return 732;
3403                                                 }
3404                                             }
3405                                           else
3406                                             {
3407                                               /* 33222222222211111111110000000000
3408                                                  10987654321098765432109876543210
3409                                                  xxx11010x10xxxxxxx1101xxxxxxxxxx
3410                                                  autizb.  */
3411                                               return 706;
3412                                             }
3413                                         }
3414                                     }
3415                                 }
3416                               else
3417                                 {
3418                                   if (((word >> 12) & 0x1) == 0)
3419                                     {
3420                                       if (((word >> 13) & 0x1) == 0)
3421                                         {
3422                                           if (((word >> 14) & 0x1) == 0)
3423                                             {
3424                                               if (((word >> 30) & 0x1) == 0)
3425                                                 {
3426                                                   /* 33222222222211111111110000000000
3427                                                      10987654321098765432109876543210
3428                                                      x0x11010xx0xxxxxx00011xxxxxxxxxx
3429                                                      sdiv.  */
3430                                                   return 712;
3431                                                 }
3432                                               else
3433                                                 {
3434                                                   if (((word >> 16) & 0x1) == 0)
3435                                                     {
3436                                                       /* 33222222222211111111110000000000
3437                                                          10987654321098765432109876543210
3438                                                          x1x11010xx0xxxx0x00011xxxxxxxxxx
3439                                                          rev.  */
3440                                                       return 688;
3441                                                     }
3442                                                   else
3443                                                     {
3444                                                       /* 33222222222211111111110000000000
3445                                                          10987654321098765432109876543210
3446                                                          x1x11010xx0xxxx1x00011xxxxxxxxxx
3447                                                          pacdb.  */
3448                                                       return 696;
3449                                                     }
3450                                                 }
3451                                             }
3452                                           else
3453                                             {
3454                                               /* 33222222222211111111110000000000
3455                                                  10987654321098765432109876543210
3456                                                  xxx11010xx0xxxxxx10011xxxxxxxxxx
3457                                                  crc32x.  */
3458                                               return 730;
3459                                             }
3460                                         }
3461                                       else
3462                                         {
3463                                           if (((word >> 30) & 0x1) == 0)
3464                                             {
3465                                               /* 33222222222211111111110000000000
3466                                                  10987654321098765432109876543210
3467                                                  x0x11010xx0xxxxxxx1011xxxxxxxxxx
3468                                                  rorv.  */
3469                                               return 719;
3470                                             }
3471                                           else
3472                                             {
3473                                               /* 33222222222211111111110000000000
3474                                                  10987654321098765432109876543210
3475                                                  x1x11010xx0xxxxxxx1011xxxxxxxxxx
3476                                                  pacdzb.  */
3477                                               return 704;
3478                                             }
3479                                         }
3480                                     }
3481                                   else
3482                                     {
3483                                       if (((word >> 13) & 0x1) == 0)
3484                                         {
3485                                           if (((word >> 14) & 0x1) == 0)
3486                                             {
3487                                               /* 33222222222211111111110000000000
3488                                                  10987654321098765432109876543210
3489                                                  xxx11010xx0xxxxxx00111xxxxxxxxxx
3490                                                  autdb.  */
3491                                               return 700;
3492                                             }
3493                                           else
3494                                             {
3495                                               /* 33222222222211111111110000000000
3496                                                  10987654321098765432109876543210
3497                                                  xxx11010xx0xxxxxx10111xxxxxxxxxx
3498                                                  crc32cx.  */
3499                                               return 734;
3500                                             }
3501                                         }
3502                                       else
3503                                         {
3504                                           /* 33222222222211111111110000000000
3505                                              10987654321098765432109876543210
3506                                              xxx11010xx0xxxxxxx1111xxxxxxxxxx
3507                                              autdzb.  */
3508                                           return 708;
3509                                         }
3510                                     }
3511                                 }
3512                             }
3513                         }
3514                     }
3515                   else
3516                     {
3517                       if (((word >> 29) & 0x1) == 0)
3518                         {
3519                           if (((word >> 30) & 0x1) == 0)
3520                             {
3521                               /* 33222222222211111111110000000000
3522                                  10987654321098765432109876543210
3523                                  x00x1010xx1xxxxxxxxxxxxxxxxxxxxx
3524                                  bic.  */
3525                               return 999;
3526                             }
3527                           else
3528                             {
3529                               /* 33222222222211111111110000000000
3530                                  10987654321098765432109876543210
3531                                  x10x1010xx1xxxxxxxxxxxxxxxxxxxxx
3532                                  eon.  */
3533                               return 1006;
3534                             }
3535                         }
3536                       else
3537                         {
3538                           if (((word >> 30) & 0x1) == 0)
3539                             {
3540                               /* 33222222222211111111110000000000
3541                                  10987654321098765432109876543210
3542                                  x01x1010xx1xxxxxxxxxxxxxxxxxxxxx
3543                                  orn.  */
3544                               return 1003;
3545                             }
3546                           else
3547                             {
3548                               /* 33222222222211111111110000000000
3549                                  10987654321098765432109876543210
3550                                  x11x1010xx1xxxxxxxxxxxxxxxxxxxxx
3551                                  bics.  */
3552                               return 1009;
3553                             }
3554                         }
3555                     }
3556                 }
3557             }
3558           else
3559             {
3560               if (((word >> 27) & 0x1) == 0)
3561                 {
3562                   if (((word >> 23) & 0x1) == 0)
3563                     {
3564                       if (((word >> 29) & 0x1) == 0)
3565                         {
3566                           if (((word >> 30) & 0x1) == 0)
3567                             {
3568                               /* 33222222222211111111110000000000
3569                                  10987654321098765432109876543210
3570                                  x00x00110xxxxxxxxxxxxxxxxxxxxxxx
3571                                  sbfm.  */
3572                               return 618;
3573                             }
3574                           else
3575                             {
3576                               /* 33222222222211111111110000000000
3577                                  10987654321098765432109876543210
3578                                  x10x00110xxxxxxxxxxxxxxxxxxxxxxx
3579                                  ubfm.  */
3580                               return 629;
3581                             }
3582                         }
3583                       else
3584                         {
3585                           /* 33222222222211111111110000000000
3586                              10987654321098765432109876543210
3587                              xx1x00110xxxxxxxxxxxxxxxxxxxxxxx
3588                              bfm.  */
3589                           return 625;
3590                         }
3591                     }
3592                   else
3593                     {
3594                       /* 33222222222211111111110000000000
3595                          10987654321098765432109876543210
3596                          xxxx00111xxxxxxxxxxxxxxxxxxxxxxx
3597                          extr.  */
3598                       return 758;
3599                     }
3600                 }
3601               else
3602                 {
3603                   if (((word >> 21) & 0x1) == 0)
3604                     {
3605                       if (((word >> 28) & 0x1) == 0)
3606                         {
3607                           if (((word >> 29) & 0x1) == 0)
3608                             {
3609                               if (((word >> 30) & 0x1) == 0)
3610                                 {
3611                                   /* 33222222222211111111110000000000
3612                                      10987654321098765432109876543210
3613                                      x0001011xx0xxxxxxxxxxxxxxxxxxxxx
3614                                      add.  */
3615                                   return 21;
3616                                 }
3617                               else
3618                                 {
3619                                   /* 33222222222211111111110000000000
3620                                      10987654321098765432109876543210
3621                                      x1001011xx0xxxxxxxxxxxxxxxxxxxxx
3622                                      sub.  */
3623                                   return 24;
3624                                 }
3625                             }
3626                           else
3627                             {
3628                               if (((word >> 30) & 0x1) == 0)
3629                                 {
3630                                   /* 33222222222211111111110000000000
3631                                      10987654321098765432109876543210
3632                                      x0101011xx0xxxxxxxxxxxxxxxxxxxxx
3633                                      adds.  */
3634                                   return 22;
3635                                 }
3636                               else
3637                                 {
3638                                   /* 33222222222211111111110000000000
3639                                      10987654321098765432109876543210
3640                                      x1101011xx0xxxxxxxxxxxxxxxxxxxxx
3641                                      subs.  */
3642                                   return 26;
3643                                 }
3644                             }
3645                         }
3646                       else
3647                         {
3648                           if (((word >> 15) & 0x1) == 0)
3649                             {
3650                               if (((word >> 22) & 0x1) == 0)
3651                                 {
3652                                   /* 33222222222211111111110000000000
3653                                      10987654321098765432109876543210
3654                                      xxx11011x00xxxxx0xxxxxxxxxxxxxxx
3655                                      madd.  */
3656                                   return 735;
3657                                 }
3658                               else
3659                                 {
3660                                   if (((word >> 23) & 0x1) == 0)
3661                                     {
3662                                       /* 33222222222211111111110000000000
3663                                          10987654321098765432109876543210
3664                                          xxx11011010xxxxx0xxxxxxxxxxxxxxx
3665                                          smulh.  */
3666                                       return 743;
3667                                     }
3668                                   else
3669                                     {
3670                                       /* 33222222222211111111110000000000
3671                                          10987654321098765432109876543210
3672                                          xxx11011110xxxxx0xxxxxxxxxxxxxxx
3673                                          umulh.  */
3674                                       return 748;
3675                                     }
3676                                 }
3677                             }
3678                           else
3679                             {
3680                               /* 33222222222211111111110000000000
3681                                  10987654321098765432109876543210
3682                                  xxx11011xx0xxxxx1xxxxxxxxxxxxxxx
3683                                  msub.  */
3684                               return 737;
3685                             }
3686                         }
3687                     }
3688                   else
3689                     {
3690                       if (((word >> 23) & 0x1) == 0)
3691                         {
3692                           if (((word >> 28) & 0x1) == 0)
3693                             {
3694                               if (((word >> 29) & 0x1) == 0)
3695                                 {
3696                                   if (((word >> 30) & 0x1) == 0)
3697                                     {
3698                                       /* 33222222222211111111110000000000
3699                                          10987654321098765432109876543210
3700                                          x00010110x1xxxxxxxxxxxxxxxxxxxxx
3701                                          add.  */
3702                                       return 6;
3703                                     }
3704                                   else
3705                                     {
3706                                       /* 33222222222211111111110000000000
3707                                          10987654321098765432109876543210
3708                                          x10010110x1xxxxxxxxxxxxxxxxxxxxx
3709                                          sub.  */
3710                                       return 9;
3711                                     }
3712                                 }
3713                               else
3714                                 {
3715                                   if (((word >> 30) & 0x1) == 0)
3716                                     {
3717                                       /* 33222222222211111111110000000000
3718                                          10987654321098765432109876543210
3719                                          x01010110x1xxxxxxxxxxxxxxxxxxxxx
3720                                          adds.  */
3721                                       return 7;
3722                                     }
3723                                   else
3724                                     {
3725                                       /* 33222222222211111111110000000000
3726                                          10987654321098765432109876543210
3727                                          x11010110x1xxxxxxxxxxxxxxxxxxxxx
3728                                          subs.  */
3729                                       return 10;
3730                                     }
3731                                 }
3732                             }
3733                           else
3734                             {
3735                               if (((word >> 15) & 0x1) == 0)
3736                                 {
3737                                   /* 33222222222211111111110000000000
3738                                      10987654321098765432109876543210
3739                                      xxx110110x1xxxxx0xxxxxxxxxxxxxxx
3740                                      smaddl.  */
3741                                   return 739;
3742                                 }
3743                               else
3744                                 {
3745                                   /* 33222222222211111111110000000000
3746                                      10987654321098765432109876543210
3747                                      xxx110110x1xxxxx1xxxxxxxxxxxxxxx
3748                                      smsubl.  */
3749                                   return 741;
3750                                 }
3751                             }
3752                         }
3753                       else
3754                         {
3755                           if (((word >> 15) & 0x1) == 0)
3756                             {
3757                               /* 33222222222211111111110000000000
3758                                  10987654321098765432109876543210
3759                                  xxxx10111x1xxxxx0xxxxxxxxxxxxxxx
3760                                  umaddl.  */
3761                               return 744;
3762                             }
3763                           else
3764                             {
3765                               /* 33222222222211111111110000000000
3766                                  10987654321098765432109876543210
3767                                  xxxx10111x1xxxxx1xxxxxxxxxxxxxxx
3768                                  umsubl.  */
3769                               return 746;
3770                             }
3771                         }
3772                     }
3773                 }
3774             }
3775         }
3776     }
3777   else
3778     {
3779       if (((word >> 27) & 0x1) == 0)
3780         {
3781           if (((word >> 28) & 0x1) == 0)
3782             {
3783               if (((word >> 24) & 0x1) == 0)
3784                 {
3785                   if (((word >> 29) & 0x1) == 0)
3786                     {
3787                       if (((word >> 13) & 0x1) == 0)
3788                         {
3789                           if (((word >> 14) & 0x1) == 0)
3790                             {
3791                               if (((word >> 15) & 0x1) == 0)
3792                                 {
3793                                   if (((word >> 21) & 0x1) == 0)
3794                                     {
3795                                       if (((word >> 30) & 0x1) == 0)
3796                                         {
3797                                           if (((word >> 31) & 0x1) == 0)
3798                                             {
3799                                               if (((word >> 16) & 0x1) == 0)
3800                                                 {
3801                                                   if (((word >> 17) & 0x1) == 0)
3802                                                     {
3803                                                       if (((word >> 18) & 0x1) == 0)
3804                                                         {
3805                                                           if (((word >> 19) & 0x1) == 0)
3806                                                             {
3807                                                               if (((word >> 20) & 0x1) == 0)
3808                                                                 {
3809                                                                   /* 33222222222211111111110000000000
3810                                                                      10987654321098765432109876543210
3811                                                                      000001x0xx000000000xxxxxxxxxxxxx
3812                                                                      add.  */
3813                                                                   return 1280;
3814                                                                 }
3815                                                               else
3816                                                                 {
3817                                                                   /* 33222222222211111111110000000000
3818                                                                      10987654321098765432109876543210
3819                                                                      000001x0xx010000000xxxxxxxxxxxxx
3820                                                                      mul.  */
3821                                                                   return 1749;
3822                                                                 }
3823                                                             }
3824                                                           else
3825                                                             {
3826                                                               if (((word >> 20) & 0x1) == 0)
3827                                                                 {
3828                                                                   /* 33222222222211111111110000000000
3829                                                                      10987654321098765432109876543210
3830                                                                      000001x0xx001000000xxxxxxxxxxxxx
3831                                                                      smax.  */
3832                                                                   return 1828;
3833                                                                 }
3834                                                               else
3835                                                                 {
3836                                                                   /* 33222222222211111111110000000000
3837                                                                      10987654321098765432109876543210
3838                                                                      000001x0xx011000000xxxxxxxxxxxxx
3839                                                                      orr.  */
3840                                                                   return 1760;
3841                                                                 }
3842                                                             }
3843                                                         }
3844                                                       else
3845                                                         {
3846                                                           if (((word >> 19) & 0x1) == 0)
3847                                                             {
3848                                                               /* 33222222222211111111110000000000
3849                                                                  10987654321098765432109876543210
3850                                                                  000001x0xx0x0100000xxxxxxxxxxxxx
3851                                                                  sdiv.  */
3852                                                               return 1819;
3853                                                             }
3854                                                           else
3855                                                             {
3856                                                               /* 33222222222211111111110000000000
3857                                                                  10987654321098765432109876543210
3858                                                                  000001x0xx0x1100000xxxxxxxxxxxxx
3859                                                                  sabd.  */
3860                                                               return 1810;
3861                                                             }
3862                                                         }
3863                                                     }
3864                                                   else
3865                                                     {
3866                                                       if (((word >> 18) & 0x1) == 0)
3867                                                         {
3868                                                           if (((word >> 19) & 0x1) == 0)
3869                                                             {
3870                                                               /* 33222222222211111111110000000000
3871                                                                  10987654321098765432109876543210
3872                                                                  000001x0xx0x0010000xxxxxxxxxxxxx
3873                                                                  smulh.  */
3874                                                               return 1833;
3875                                                             }
3876                                                           else
3877                                                             {
3878                                                               if (((word >> 20) & 0x1) == 0)
3879                                                                 {
3880                                                                   /* 33222222222211111111110000000000
3881                                                                      10987654321098765432109876543210
3882                                                                      000001x0xx001010000xxxxxxxxxxxxx
3883                                                                      smin.  */
3884                                                                   return 1831;
3885                                                                 }
3886                                                               else
3887                                                                 {
3888                                                                   /* 33222222222211111111110000000000
3889                                                                      10987654321098765432109876543210
3890                                                                      000001x0xx011010000xxxxxxxxxxxxx
3891                                                                      and.  */
3892                                                                   return 1288;
3893                                                                 }
3894                                                             }
3895                                                         }
3896                                                       else
3897                                                         {
3898                                                           /* 33222222222211111111110000000000
3899                                                              10987654321098765432109876543210
3900                                                              000001x0xx0xx110000xxxxxxxxxxxxx
3901                                                              sdivr.  */
3902                                                           return 1820;
3903                                                         }
3904                                                     }
3905                                                 }
3906                                               else
3907                                                 {
3908                                                   if (((word >> 17) & 0x1) == 0)
3909                                                     {
3910                                                       if (((word >> 18) & 0x1) == 0)
3911                                                         {
3912                                                           if (((word >> 19) & 0x1) == 0)
3913                                                             {
3914                                                               /* 33222222222211111111110000000000
3915                                                                  10987654321098765432109876543210
3916                                                                  000001x0xx0x0001000xxxxxxxxxxxxx
3917                                                                  sub.  */
3918                                                               return 1949;
3919                                                             }
3920                                                           else
3921                                                             {
3922                                                               if (((word >> 20) & 0x1) == 0)
3923                                                                 {
3924                                                                   /* 33222222222211111111110000000000
3925                                                                      10987654321098765432109876543210
3926                                                                      000001x0xx001001000xxxxxxxxxxxxx
3927                                                                      umax.  */
3928                                                                   return 1977;
3929                                                                 }
3930                                                               else
3931                                                                 {
3932                                                                   /* 33222222222211111111110000000000
3933                                                                      10987654321098765432109876543210
3934                                                                      000001x0xx011001000xxxxxxxxxxxxx
3935                                                                      eor.  */
3936                                                                   return 1375;
3937                                                                 }
3938                                                             }
3939                                                         }
3940                                                       else
3941                                                         {
3942                                                           if (((word >> 19) & 0x1) == 0)
3943                                                             {
3944                                                               /* 33222222222211111111110000000000
3945                                                                  10987654321098765432109876543210
3946                                                                  000001x0xx0x0101000xxxxxxxxxxxxx
3947                                                                  udiv.  */
3948                                                               return 1971;
3949                                                             }
3950                                                           else
3951                                                             {
3952                                                               /* 33222222222211111111110000000000
3953                                                                  10987654321098765432109876543210
3954                                                                  000001x0xx0x1101000xxxxxxxxxxxxx
3955                                                                  uabd.  */
3956                                                               return 1962;
3957                                                             }
3958                                                         }
3959                                                     }
3960                                                   else
3961                                                     {
3962                                                       if (((word >> 18) & 0x1) == 0)
3963                                                         {
3964                                                           if (((word >> 19) & 0x1) == 0)
3965                                                             {
3966                                                               if (((word >> 20) & 0x1) == 0)
3967                                                                 {
3968                                                                   /* 33222222222211111111110000000000
3969                                                                      10987654321098765432109876543210
3970                                                                      000001x0xx000011000xxxxxxxxxxxxx
3971                                                                      subr.  */
3972                                                                   return 1951;
3973                                                                 }
3974                                                               else
3975                                                                 {
3976                                                                   /* 33222222222211111111110000000000
3977                                                                      10987654321098765432109876543210
3978                                                                      000001x0xx010011000xxxxxxxxxxxxx
3979                                                                      umulh.  */
3980                                                                   return 1982;
3981                                                                 }
3982                                                             }
3983                                                           else
3984                                                             {
3985                                                               if (((word >> 20) & 0x1) == 0)
3986                                                                 {
3987                                                                   /* 33222222222211111111110000000000
3988                                                                      10987654321098765432109876543210
3989                                                                      000001x0xx001011000xxxxxxxxxxxxx
3990                                                                      umin.  */
3991                                                                   return 1980;
3992                                                                 }
3993                                                               else
3994                                                                 {
3995                                                                   /* 33222222222211111111110000000000
3996                                                                      10987654321098765432109876543210
3997                                                                      000001x0xx011011000xxxxxxxxxxxxx
3998                                                                      bic.  */
3999                                                                   return 1300;
4000                                                                 }
4001                                                             }
4002                                                         }
4003                                                       else
4004                                                         {
4005                                                           /* 33222222222211111111110000000000
4006                                                              10987654321098765432109876543210
4007                                                              000001x0xx0xx111000xxxxxxxxxxxxx
4008                                                              udivr.  */
4009                                                           return 1972;
4010                                                         }
4011                                                     }
4012                                                 }
4013                                             }
4014                                           else
4015                                             {
4016                                               if (((word >> 23) & 0x1) == 0)
4017                                                 {
4018                                                   /* 33222222222211111111110000000000
4019                                                      10987654321098765432109876543210
4020                                                      100001x00x0xxxxx000xxxxxxxxxxxxx
4021                                                      ld1sb.  */
4022                                                   return 1562;
4023                                                 }
4024                                               else
4025                                                 {
4026                                                   /* 33222222222211111111110000000000
4027                                                      10987654321098765432109876543210
4028                                                      100001x01x0xxxxx000xxxxxxxxxxxxx
4029                                                      ld1sh.  */
4030                                                   return 1573;
4031                                                 }
4032                                             }
4033                                         }
4034                                       else
4035                                         {
4036                                           if (((word >> 31) & 0x1) == 0)
4037                                             {
4038                                               if (((word >> 12) & 0x1) == 0)
4039                                                 {
4040                                                   if (((word >> 10) & 0x1) == 0)
4041                                                     {
4042                                                       if (((word >> 11) & 0x1) == 0)
4043                                                         {
4044                                                           /* 33222222222211111111110000000000
4045                                                              10987654321098765432109876543210
4046                                                              010001x0xx0xxxxx000000xxxxxxxxxx
4047                                                              sdot.  */
4048                                                           return 1821;
4049                                                         }
4050                                                       else
4051                                                         {
4052                                                           /* 33222222222211111111110000000000
4053                                                              10987654321098765432109876543210
4054                                                              010001x0xx0xxxxx000010xxxxxxxxxx
4055                                                              sqdmlalbt.  */
4056                                                           return 2171;
4057                                                         }
4058                                                     }
4059                                                   else
4060                                                     {
4061                                                       if (((word >> 11) & 0x1) == 0)
4062                                                         {
4063                                                           /* 33222222222211111111110000000000
4064                                                              10987654321098765432109876543210
4065                                                              010001x0xx0xxxxx000001xxxxxxxxxx
4066                                                              udot.  */
4067                                                           return 1973;
4068                                                         }
4069                                                       else
4070                                                         {
4071                                                           /* 33222222222211111111110000000000
4072                                                              10987654321098765432109876543210
4073                                                              010001x0xx0xxxxx000011xxxxxxxxxx
4074                                                              sqdmlslbt.  */
4075                                                           return 2178;
4076                                                         }
4077                                                     }
4078                                                 }
4079                                               else
4080                                                 {
4081                                                   /* 33222222222211111111110000000000
4082                                                      10987654321098765432109876543210
4083                                                      010001x0xx0xxxxx0001xxxxxxxxxxxx
4084                                                      cdot.  */
4085                                                   return 2060;
4086                                                 }
4087                                             }
4088                                           else
4089                                             {
4090                                               if (((word >> 23) & 0x1) == 0)
4091                                                 {
4092                                                   /* 33222222222211111111110000000000
4093                                                      10987654321098765432109876543210
4094                                                      110001x00x0xxxxx000xxxxxxxxxxxxx
4095                                                      ld1sb.  */
4096                                                   return 1566;
4097                                                 }
4098                                               else
4099                                                 {
4100                                                   /* 33222222222211111111110000000000
4101                                                      10987654321098765432109876543210
4102                                                      110001x01x0xxxxx000xxxxxxxxxxxxx
4103                                                      ld1sh.  */
4104                                                   return 1577;
4105                                                 }
4106                                             }
4107                                         }
4108                                     }
4109                                   else
4110                                     {
4111                                       if (((word >> 30) & 0x1) == 0)
4112                                         {
4113                                           if (((word >> 31) & 0x1) == 0)
4114                                             {
4115                                               if (((word >> 10) & 0x1) == 0)
4116                                                 {
4117                                                   if (((word >> 11) & 0x1) == 0)
4118                                                     {
4119                                                       if (((word >> 12) & 0x1) == 0)
4120                                                         {
4121                                                           /* 33222222222211111111110000000000
4122                                                              10987654321098765432109876543210
4123                                                              000001x0xx1xxxxx000000xxxxxxxxxx
4124                                                              add.  */
4125                                                           return 1278;
4126                                                         }
4127                                                       else
4128                                                         {
4129                                                           /* 33222222222211111111110000000000
4130                                                              10987654321098765432109876543210
4131                                                              000001x0xx1xxxxx000100xxxxxxxxxx
4132                                                              sqadd.  */
4133                                                           return 1835;
4134                                                         }
4135                                                     }
4136                                                   else
4137                                                     {
4138                                                       /* 33222222222211111111110000000000
4139                                                          10987654321098765432109876543210
4140                                                          000001x0xx1xxxxx000x10xxxxxxxxxx
4141                                                          sqsub.  */
4142                                                       return 1865;
4143                                                     }
4144                                                 }
4145                                               else
4146                                                 {
4147                                                   if (((word >> 11) & 0x1) == 0)
4148                                                     {
4149                                                       if (((word >> 12) & 0x1) == 0)
4150                                                         {
4151                                                           /* 33222222222211111111110000000000
4152                                                              10987654321098765432109876543210
4153                                                              000001x0xx1xxxxx000001xxxxxxxxxx
4154                                                              sub.  */
4155                                                           return 1947;
4156                                                         }
4157                                                       else
4158                                                         {
4159                                                           /* 33222222222211111111110000000000
4160                                                              10987654321098765432109876543210
4161                                                              000001x0xx1xxxxx000101xxxxxxxxxx
4162                                                              uqadd.  */
4163                                                           return 1983;
4164                                                         }
4165                                                     }
4166                                                   else
4167                                                     {
4168                                                       /* 33222222222211111111110000000000
4169                                                          10987654321098765432109876543210
4170                                                          000001x0xx1xxxxx000x11xxxxxxxxxx
4171                                                          uqsub.  */
4172                                                       return 2013;
4173                                                     }
4174                                                 }
4175                                             }
4176                                           else
4177                                             {
4178                                               if (((word >> 23) & 0x1) == 0)
4179                                                 {
4180                                                   /* 33222222222211111111110000000000
4181                                                      10987654321098765432109876543210
4182                                                      100001x00x1xxxxx000xxxxxxxxxxxxx
4183                                                      prfb.  */
4184                                                   return 1768;
4185                                                 }
4186                                               else
4187                                                 {
4188                                                   /* 33222222222211111111110000000000
4189                                                      10987654321098765432109876543210
4190                                                      100001x01x1xxxxx000xxxxxxxxxxxxx
4191                                                      ld1sh.  */
4192                                                   return 1574;
4193                                                 }
4194                                             }
4195                                         }
4196                                       else
4197                                         {
4198                                           if (((word >> 23) & 0x1) == 0)
4199                                             {
4200                                               if (((word >> 31) & 0x1) == 0)
4201                                                 {
4202                                                   if (((word >> 10) & 0x1) == 0)
4203                                                     {
4204                                                       if (((word >> 11) & 0x1) == 0)
4205                                                         {
4206                                                           /* 33222222222211111111110000000000
4207                                                              10987654321098765432109876543210
4208                                                              010001x00x1xxxxx000x00xxxxxxxxxx
4209                                                              sqrdmlah.  */
4210                                                           return 2196;
4211                                                         }
4212                                                       else
4213                                                         {
4214                                                           /* 33222222222211111111110000000000
4215                                                              10987654321098765432109876543210
4216                                                              010001x00x1xxxxx000x10xxxxxxxxxx
4217                                                              mla.  */
4218                                                           return 2103;
4219                                                         }
4220                                                     }
4221                                                   else
4222                                                     {
4223                                                       if (((word >> 11) & 0x1) == 0)
4224                                                         {
4225                                                           /* 33222222222211111111110000000000
4226                                                              10987654321098765432109876543210
4227                                                              010001x00x1xxxxx000x01xxxxxxxxxx
4228                                                              sqrdmlsh.  */
4229                                                           return 2200;
4230                                                         }
4231                                                       else
4232                                                         {
4233                                                           /* 33222222222211111111110000000000
4234                                                              10987654321098765432109876543210
4235                                                              010001x00x1xxxxx000x11xxxxxxxxxx
4236                                                              mls.  */
4237                                                           return 2106;
4238                                                         }
4239                                                     }
4240                                                 }
4241                                               else
4242                                                 {
4243                                                   /* 33222222222211111111110000000000
4244                                                      10987654321098765432109876543210
4245                                                      110001x00x1xxxxx000xxxxxxxxxxxxx
4246                                                      prfb.  */
4247                                                   return 1769;
4248                                                 }
4249                                             }
4250                                           else
4251                                             {
4252                                               if (((word >> 31) & 0x1) == 0)
4253                                                 {
4254                                                   if (((word >> 10) & 0x1) == 0)
4255                                                     {
4256                                                       if (((word >> 11) & 0x1) == 0)
4257                                                         {
4258                                                           if (((word >> 12) & 0x1) == 0)
4259                                                             {
4260                                                               if (((word >> 22) & 0x1) == 0)
4261                                                                 {
4262                                                                   /* 33222222222211111111110000000000
4263                                                                      10987654321098765432109876543210
4264                                                                      010001x0101xxxxx000000xxxxxxxxxx
4265                                                                      sdot.  */
4266                                                                   return 1822;
4267                                                                 }
4268                                                               else
4269                                                                 {
4270                                                                   /* 33222222222211111111110000000000
4271                                                                      10987654321098765432109876543210
4272                                                                      010001x0111xxxxx000000xxxxxxxxxx
4273                                                                      sdot.  */
4274                                                                   return 1823;
4275                                                                 }
4276                                                             }
4277                                                           else
4278                                                             {
4279                                                               if (((word >> 22) & 0x1) == 0)
4280                                                                 {
4281                                                                   /* 33222222222211111111110000000000
4282                                                                      10987654321098765432109876543210
4283                                                                      010001x0101xxxxx000100xxxxxxxxxx
4284                                                                      sqrdmlah.  */
4285                                                                   return 2197;
4286                                                                 }
4287                                                               else
4288                                                                 {
4289                                                                   /* 33222222222211111111110000000000
4290                                                                      10987654321098765432109876543210
4291                                                                      010001x0111xxxxx000100xxxxxxxxxx
4292                                                                      sqrdmlah.  */
4293                                                                   return 2198;
4294                                                                 }
4295                                                             }
4296                                                         }
4297                                                       else
4298                                                         {
4299                                                           if (((word >> 12) & 0x1) == 0)
4300                                                             {
4301                                                               if (((word >> 22) & 0x1) == 0)
4302                                                                 {
4303                                                                   /* 33222222222211111111110000000000
4304                                                                      10987654321098765432109876543210
4305                                                                      010001x0101xxxxx000010xxxxxxxxxx
4306                                                                      mla.  */
4307                                                                   return 2104;
4308                                                                 }
4309                                                               else
4310                                                                 {
4311                                                                   /* 33222222222211111111110000000000
4312                                                                      10987654321098765432109876543210
4313                                                                      010001x0111xxxxx000010xxxxxxxxxx
4314                                                                      mla.  */
4315                                                                   return 2105;
4316                                                                 }
4317                                                             }
4318                                                           else
4319                                                             {
4320                                                               /* 33222222222211111111110000000000
4321                                                                  10987654321098765432109876543210
4322                                                                  010001x01x1xxxxx000110xxxxxxxxxx
4323                                                                  usdot.  */
4324                                                               return 2398;
4325                                                             }
4326                                                         }
4327                                                     }
4328                                                   else
4329                                                     {
4330                                                       if (((word >> 11) & 0x1) == 0)
4331                                                         {
4332                                                           if (((word >> 12) & 0x1) == 0)
4333                                                             {
4334                                                               if (((word >> 22) & 0x1) == 0)
4335                                                                 {
4336                                                                   /* 33222222222211111111110000000000
4337                                                                      10987654321098765432109876543210
4338                                                                      010001x0101xxxxx000001xxxxxxxxxx
4339                                                                      udot.  */
4340                                                                   return 1974;
4341                                                                 }
4342                                                               else
4343                                                                 {
4344                                                                   /* 33222222222211111111110000000000
4345                                                                      10987654321098765432109876543210
4346                                                                      010001x0111xxxxx000001xxxxxxxxxx
4347                                                                      udot.  */
4348                                                                   return 1975;
4349                                                                 }
4350                                                             }
4351                                                           else
4352                                                             {
4353                                                               if (((word >> 22) & 0x1) == 0)
4354                                                                 {
4355                                                                   /* 33222222222211111111110000000000
4356                                                                      10987654321098765432109876543210
4357                                                                      010001x0101xxxxx000101xxxxxxxxxx
4358                                                                      sqrdmlsh.  */
4359                                                                   return 2201;
4360                                                                 }
4361                                                               else
4362                                                                 {
4363                                                                   /* 33222222222211111111110000000000
4364                                                                      10987654321098765432109876543210
4365                                                                      010001x0111xxxxx000101xxxxxxxxxx
4366                                                                      sqrdmlsh.  */
4367                                                                   return 2202;
4368                                                                 }
4369                                                             }
4370                                                         }
4371                                                       else
4372                                                         {
4373                                                           if (((word >> 12) & 0x1) == 0)
4374                                                             {
4375                                                               if (((word >> 22) & 0x1) == 0)
4376                                                                 {
4377                                                                   /* 33222222222211111111110000000000
4378                                                                      10987654321098765432109876543210
4379                                                                      010001x0101xxxxx000011xxxxxxxxxx
4380                                                                      mls.  */
4381                                                                   return 2107;
4382                                                                 }
4383                                                               else
4384                                                                 {
4385                                                                   /* 33222222222211111111110000000000
4386                                                                      10987654321098765432109876543210
4387                                                                      010001x0111xxxxx000011xxxxxxxxxx
4388                                                                      mls.  */
4389                                                                   return 2108;
4390                                                                 }
4391                                                             }
4392                                                           else
4393                                                             {
4394                                                               /* 33222222222211111111110000000000
4395                                                                  10987654321098765432109876543210
4396                                                                  010001x01x1xxxxx000111xxxxxxxxxx
4397                                                                  sudot.  */
4398                                                               return 2399;
4399                                                             }
4400                                                         }
4401                                                     }
4402                                                 }
4403                                               else
4404                                                 {
4405                                                   /* 33222222222211111111110000000000
4406                                                      10987654321098765432109876543210
4407                                                      110001x01x1xxxxx000xxxxxxxxxxxxx
4408                                                      ld1sh.  */
4409                                                   return 1578;
4410                                                 }
4411                                             }
4412                                         }
4413                                     }
4414                                 }
4415                               else
4416                                 {
4417                                   if (((word >> 31) & 0x1) == 0)
4418                                     {
4419                                       if (((word >> 21) & 0x1) == 0)
4420                                         {
4421                                           if (((word >> 16) & 0x1) == 0)
4422                                             {
4423                                               if (((word >> 17) & 0x1) == 0)
4424                                                 {
4425                                                   if (((word >> 18) & 0x1) == 0)
4426                                                     {
4427                                                       if (((word >> 19) & 0x1) == 0)
4428                                                         {
4429                                                           if (((word >> 20) & 0x1) == 0)
4430                                                             {
4431                                                               /* 33222222222211111111110000000000
4432                                                                  10987654321098765432109876543210
4433                                                                  0x0001x0xx000000100xxxxxxxxxxxxx
4434                                                                  asr.  */
4435                                                               return 1296;
4436                                                             }
4437                                                           else
4438                                                             {
4439                                                               if (((word >> 30) & 0x1) == 0)
4440                                                                 {
4441                                                                   /* 33222222222211111111110000000000
4442                                                                      10987654321098765432109876543210
4443                                                                      000001x0xx010000100xxxxxxxxxxxxx
4444                                                                      asr.  */
4445                                                                   return 1294;
4446                                                                 }
4447                                                               else
4448                                                                 {
4449                                                                   /* 33222222222211111111110000000000
4450                                                                      10987654321098765432109876543210
4451                                                                      010001x0xx010000100xxxxxxxxxxxxx
4452                                                                      shadd.  */
4453                                                                   return 2137;
4454                                                                 }
4455                                                             }
4456                                                         }
4457                                                       else
4458                                                         {
4459                                                           if (((word >> 20) & 0x1) == 0)
4460                                                             {
4461                                                               /* 33222222222211111111110000000000
4462                                                                  10987654321098765432109876543210
4463                                                                  0x0001x0xx001000100xxxxxxxxxxxxx
4464                                                                  sqshl.  */
4465                                                               return 2215;
4466                                                             }
4467                                                           else
4468                                                             {
4469                                                               if (((word >> 30) & 0x1) == 0)
4470                                                                 {
4471                                                                   /* 33222222222211111111110000000000
4472                                                                      10987654321098765432109876543210
4473                                                                      000001x0xx011000100xxxxxxxxxxxxx
4474                                                                      asr.  */
4475                                                                   return 1295;
4476                                                                 }
4477                                                               else
4478                                                                 {
4479                                                                   /* 33222222222211111111110000000000
4480                                                                      10987654321098765432109876543210
4481                                                                      010001x0xx011000100xxxxxxxxxxxxx
4482                                                                      sqadd.  */
4483                                                                   return 2166;
4484                                                                 }
4485                                                             }
4486                                                         }
4487                                                     }
4488                                                   else
4489                                                     {
4490                                                       if (((word >> 19) & 0x1) == 0)
4491                                                         {
4492                                                           if (((word >> 20) & 0x1) == 0)
4493                                                             {
4494                                                               /* 33222222222211111111110000000000
4495                                                                  10987654321098765432109876543210
4496                                                                  0x0001x0xx000100100xxxxxxxxxxxxx
4497                                                                  asrd.  */
4498                                                               return 1297;
4499                                                             }
4500                                                           else
4501                                                             {
4502                                                               if (((word >> 30) & 0x1) == 0)
4503                                                                 {
4504                                                                   /* 33222222222211111111110000000000
4505                                                                      10987654321098765432109876543210
4506                                                                      000001x0xx010100100xxxxxxxxxxxxx
4507                                                                      asrr.  */
4508                                                                   return 1298;
4509                                                                 }
4510                                                               else
4511                                                                 {
4512                                                                   /* 33222222222211111111110000000000
4513                                                                      10987654321098765432109876543210
4514                                                                      010001x0xx010100100xxxxxxxxxxxxx
4515                                                                      srhadd.  */
4516                                                                   return 2228;
4517                                                                 }
4518                                                             }
4519                                                         }
4520                                                       else
4521                                                         {
4522                                                           if (((word >> 20) & 0x1) == 0)
4523                                                             {
4524                                                               if (((word >> 30) & 0x1) == 0)
4525                                                                 {
4526                                                                   /* 33222222222211111111110000000000
4527                                                                      10987654321098765432109876543210
4528                                                                      000001x0xx001100100xxxxxxxxxxxxx
4529                                                                      srshr.  */
4530                                                                   return 2232;
4531                                                                 }
4532                                                               else
4533                                                                 {
4534                                                                   /* 33222222222211111111110000000000
4535                                                                      10987654321098765432109876543210
4536                                                                      010001x0xx001100100xxxxxxxxxxxxx
4537                                                                      sqshlr.  */
4538                                                                   return 2216;
4539                                                                 }
4540                                                             }
4541                                                           else
4542                                                             {
4543                                                               /* 33222222222211111111110000000000
4544                                                                  10987654321098765432109876543210
4545                                                                  0x0001x0xx011100100xxxxxxxxxxxxx
4546                                                                  suqadd.  */
4547                                                               return 2252;
4548                                                             }
4549                                                         }
4550                                                     }
4551                                                 }
4552                                               else
4553                                                 {
4554                                                   if (((word >> 18) & 0x1) == 0)
4555                                                     {
4556                                                       if (((word >> 19) & 0x1) == 0)
4557                                                         {
4558                                                           if (((word >> 20) & 0x1) == 0)
4559                                                             {
4560                                                               /* 33222222222211111111110000000000
4561                                                                  10987654321098765432109876543210
4562                                                                  0x0001x0xx000010100xxxxxxxxxxxxx
4563                                                                  srshl.  */
4564                                                               return 2230;
4565                                                             }
4566                                                           else
4567                                                             {
4568                                                               /* 33222222222211111111110000000000
4569                                                                  10987654321098765432109876543210
4570                                                                  0x0001x0xx010010100xxxxxxxxxxxxx
4571                                                                  shsub.  */
4572                                                               return 2140;
4573                                                             }
4574                                                         }
4575                                                       else
4576                                                         {
4577                                                           if (((word >> 20) & 0x1) == 0)
4578                                                             {
4579                                                               /* 33222222222211111111110000000000
4580                                                                  10987654321098765432109876543210
4581                                                                  0x0001x0xx001010100xxxxxxxxxxxxx
4582                                                                  sqrshl.  */
4583                                                               return 2208;
4584                                                             }
4585                                                           else
4586                                                             {
4587                                                               /* 33222222222211111111110000000000
4588                                                                  10987654321098765432109876543210
4589                                                                  0x0001x0xx011010100xxxxxxxxxxxxx
4590                                                                  sqsub.  */
4591                                                               return 2222;
4592                                                             }
4593                                                         }
4594                                                     }
4595                                                   else
4596                                                     {
4597                                                       if (((word >> 19) & 0x1) == 0)
4598                                                         {
4599                                                           if (((word >> 20) & 0x1) == 0)
4600                                                             {
4601                                                               if (((word >> 30) & 0x1) == 0)
4602                                                                 {
4603                                                                   /* 33222222222211111111110000000000
4604                                                                      10987654321098765432109876543210
4605                                                                      000001x0xx000110100xxxxxxxxxxxxx
4606                                                                      sqshl.  */
4607                                                                   return 2214;
4608                                                                 }
4609                                                               else
4610                                                                 {
4611                                                                   /* 33222222222211111111110000000000
4612                                                                      10987654321098765432109876543210
4613                                                                      010001x0xx000110100xxxxxxxxxxxxx
4614                                                                      srshlr.  */
4615                                                                   return 2231;
4616                                                                 }
4617                                                             }
4618                                                           else
4619                                                             {
4620                                                               /* 33222222222211111111110000000000
4621                                                                  10987654321098765432109876543210
4622                                                                  0x0001x0xx010110100xxxxxxxxxxxxx
4623                                                                  shsubr.  */
4624                                                               return 2141;
4625                                                             }
4626                                                         }
4627                                                       else
4628                                                         {
4629                                                           if (((word >> 20) & 0x1) == 0)
4630                                                             {
4631                                                               /* 33222222222211111111110000000000
4632                                                                  10987654321098765432109876543210
4633                                                                  0x0001x0xx001110100xxxxxxxxxxxxx
4634                                                                  sqrshlr.  */
4635                                                               return 2209;
4636                                                             }
4637                                                           else
4638                                                             {
4639                                                               /* 33222222222211111111110000000000
4640                                                                  10987654321098765432109876543210
4641                                                                  0x0001x0xx011110100xxxxxxxxxxxxx
4642                                                                  sqsubr.  */
4643                                                               return 2223;
4644                                                             }
4645                                                         }
4646                                                     }
4647                                                 }
4648                                             }
4649                                           else
4650                                             {
4651                                               if (((word >> 17) & 0x1) == 0)
4652                                                 {
4653                                                   if (((word >> 18) & 0x1) == 0)
4654                                                     {
4655                                                       if (((word >> 19) & 0x1) == 0)
4656                                                         {
4657                                                           if (((word >> 20) & 0x1) == 0)
4658                                                             {
4659                                                               /* 33222222222211111111110000000000
4660                                                                  10987654321098765432109876543210
4661                                                                  0x0001x0xx000001100xxxxxxxxxxxxx
4662                                                                  lsr.  */
4663                                                               return 1740;
4664                                                             }
4665                                                           else
4666                                                             {
4667                                                               if (((word >> 30) & 0x1) == 0)
4668                                                                 {
4669                                                                   /* 33222222222211111111110000000000
4670                                                                      10987654321098765432109876543210
4671                                                                      000001x0xx010001100xxxxxxxxxxxxx
4672                                                                      lsr.  */
4673                                                                   return 1738;
4674                                                                 }
4675                                                               else
4676                                                                 {
4677                                                                   /* 33222222222211111111110000000000
4678                                                                      10987654321098765432109876543210
4679                                                                      010001x0xx010001100xxxxxxxxxxxxx
4680                                                                      uhadd.  */
4681                                                                   return 2265;
4682                                                                 }
4683                                                             }
4684                                                         }
4685                                                       else
4686                                                         {
4687                                                           if (((word >> 20) & 0x1) == 0)
4688                                                             {
4689                                                               /* 33222222222211111111110000000000
4690                                                                  10987654321098765432109876543210
4691                                                                  0x0001x0xx001001100xxxxxxxxxxxxx
4692                                                                  uqshl.  */
4693                                                               return 2295;
4694                                                             }
4695                                                           else
4696                                                             {
4697                                                               if (((word >> 30) & 0x1) == 0)
4698                                                                 {
4699                                                                   /* 33222222222211111111110000000000
4700                                                                      10987654321098765432109876543210
4701                                                                      000001x0xx011001100xxxxxxxxxxxxx
4702                                                                      lsr.  */
4703                                                                   return 1739;
4704                                                                 }
4705                                                               else
4706                                                                 {
4707                                                                   /* 33222222222211111111110000000000
4708                                                                      10987654321098765432109876543210
4709                                                                      010001x0xx011001100xxxxxxxxxxxxx
4710                                                                      uqadd.  */
4711                                                                   return 2289;
4712                                                                 }
4713                                                             }
4714                                                         }
4715                                                     }
4716                                                   else
4717                                                     {
4718                                                       if (((word >> 19) & 0x1) == 0)
4719                                                         {
4720                                                           if (((word >> 30) & 0x1) == 0)
4721                                                             {
4722                                                               /* 33222222222211111111110000000000
4723                                                                  10987654321098765432109876543210
4724                                                                  000001x0xx0x0101100xxxxxxxxxxxxx
4725                                                                  lsrr.  */
4726                                                               return 1741;
4727                                                             }
4728                                                           else
4729                                                             {
4730                                                               /* 33222222222211111111110000000000
4731                                                                  10987654321098765432109876543210
4732                                                                  010001x0xx0x0101100xxxxxxxxxxxxx
4733                                                                  urhadd.  */
4734                                                               return 2304;
4735                                                             }
4736                                                         }
4737                                                       else
4738                                                         {
4739                                                           if (((word >> 20) & 0x1) == 0)
4740                                                             {
4741                                                               if (((word >> 30) & 0x1) == 0)
4742                                                                 {
4743                                                                   /* 33222222222211111111110000000000
4744                                                                      10987654321098765432109876543210
4745                                                                      000001x0xx001101100xxxxxxxxxxxxx
4746                                                                      urshr.  */
4747                                                                   return 2307;
4748                                                                 }
4749                                                               else
4750                                                                 {
4751                                                                   /* 33222222222211111111110000000000
4752                                                                      10987654321098765432109876543210
4753                                                                      010001x0xx001101100xxxxxxxxxxxxx
4754                                                                      uqshlr.  */
4755                                                                   return 2296;
4756                                                                 }
4757                                                             }
4758                                                           else
4759                                                             {
4760                                                               /* 33222222222211111111110000000000
4761                                                                  10987654321098765432109876543210
4762                                                                  0x0001x0xx011101100xxxxxxxxxxxxx
4763                                                                  usqadd.  */
4764                                                               return 2312;
4765                                                             }
4766                                                         }
4767                                                     }
4768                                                 }
4769                                               else
4770                                                 {
4771                                                   if (((word >> 18) & 0x1) == 0)
4772                                                     {
4773                                                       if (((word >> 19) & 0x1) == 0)
4774                                                         {
4775                                                           if (((word >> 20) & 0x1) == 0)
4776                                                             {
4777                                                               if (((word >> 30) & 0x1) == 0)
4778                                                                 {
4779                                                                   /* 33222222222211111111110000000000
4780                                                                      10987654321098765432109876543210
4781                                                                      000001x0xx000011100xxxxxxxxxxxxx
4782                                                                      lsl.  */
4783                                                                   return 1734;
4784                                                                 }
4785                                                               else
4786                                                                 {
4787                                                                   /* 33222222222211111111110000000000
4788                                                                      10987654321098765432109876543210
4789                                                                      010001x0xx000011100xxxxxxxxxxxxx
4790                                                                      urshl.  */
4791                                                                   return 2305;
4792                                                                 }
4793                                                             }
4794                                                           else
4795                                                             {
4796                                                               if (((word >> 30) & 0x1) == 0)
4797                                                                 {
4798                                                                   /* 33222222222211111111110000000000
4799                                                                      10987654321098765432109876543210
4800                                                                      000001x0xx010011100xxxxxxxxxxxxx
4801                                                                      lsl.  */
4802                                                                   return 1732;
4803                                                                 }
4804                                                               else
4805                                                                 {
4806                                                                   /* 33222222222211111111110000000000
4807                                                                      10987654321098765432109876543210
4808                                                                      010001x0xx010011100xxxxxxxxxxxxx
4809                                                                      uhsub.  */
4810                                                                   return 2266;
4811                                                                 }
4812                                                             }
4813                                                         }
4814                                                       else
4815                                                         {
4816                                                           if (((word >> 20) & 0x1) == 0)
4817                                                             {
4818                                                               /* 33222222222211111111110000000000
4819                                                                  10987654321098765432109876543210
4820                                                                  0x0001x0xx001011100xxxxxxxxxxxxx
4821                                                                  uqrshl.  */
4822                                                               return 2290;
4823                                                             }
4824                                                           else
4825                                                             {
4826                                                               if (((word >> 30) & 0x1) == 0)
4827                                                                 {
4828                                                                   /* 33222222222211111111110000000000
4829                                                                      10987654321098765432109876543210
4830                                                                      000001x0xx011011100xxxxxxxxxxxxx
4831                                                                      lsl.  */
4832                                                                   return 1733;
4833                                                                 }
4834                                                               else
4835                                                                 {
4836                                                                   /* 33222222222211111111110000000000
4837                                                                      10987654321098765432109876543210
4838                                                                      010001x0xx011011100xxxxxxxxxxxxx
4839                                                                      uqsub.  */
4840                                                                   return 2299;
4841                                                                 }
4842                                                             }
4843                                                         }
4844                                                     }
4845                                                   else
4846                                                     {
4847                                                       if (((word >> 19) & 0x1) == 0)
4848                                                         {
4849                                                           if (((word >> 20) & 0x1) == 0)
4850                                                             {
4851                                                               if (((word >> 30) & 0x1) == 0)
4852                                                                 {
4853                                                                   /* 33222222222211111111110000000000
4854                                                                      10987654321098765432109876543210
4855                                                                      000001x0xx000111100xxxxxxxxxxxxx
4856                                                                      uqshl.  */
4857                                                                   return 2294;
4858                                                                 }
4859                                                               else
4860                                                                 {
4861                                                                   /* 33222222222211111111110000000000
4862                                                                      10987654321098765432109876543210
4863                                                                      010001x0xx000111100xxxxxxxxxxxxx
4864                                                                      urshlr.  */
4865                                                                   return 2306;
4866                                                                 }
4867                                                             }
4868                                                           else
4869                                                             {
4870                                                               if (((word >> 30) & 0x1) == 0)
4871                                                                 {
4872                                                                   /* 33222222222211111111110000000000
4873                                                                      10987654321098765432109876543210
4874                                                                      000001x0xx010111100xxxxxxxxxxxxx
4875                                                                      lslr.  */
4876                                                                   return 1735;
4877                                                                 }
4878                                                               else
4879                                                                 {
4880                                                                   /* 33222222222211111111110000000000
4881                                                                      10987654321098765432109876543210
4882                                                                      010001x0xx010111100xxxxxxxxxxxxx
4883                                                                      uhsubr.  */
4884                                                                   return 2267;
4885                                                                 }
4886                                                             }
4887                                                         }
4888                                                       else
4889                                                         {
4890                                                           if (((word >> 20) & 0x1) == 0)
4891                                                             {
4892                                                               if (((word >> 30) & 0x1) == 0)
4893                                                                 {
4894                                                                   /* 33222222222211111111110000000000
4895                                                                      10987654321098765432109876543210
4896                                                                      000001x0xx001111100xxxxxxxxxxxxx
4897                                                                      sqshlu.  */
4898                                                                   return 2217;
4899                                                                 }
4900                                                               else
4901                                                                 {
4902                                                                   /* 33222222222211111111110000000000
4903                                                                      10987654321098765432109876543210
4904                                                                      010001x0xx001111100xxxxxxxxxxxxx
4905                                                                      uqrshlr.  */
4906                                                                   return 2291;
4907                                                                 }
4908                                                             }
4909                                                           else
4910                                                             {
4911                                                               /* 33222222222211111111110000000000
4912                                                                  10987654321098765432109876543210
4913                                                                  0x0001x0xx011111100xxxxxxxxxxxxx
4914                                                                  uqsubr.  */
4915                                                               return 2300;
4916                                                             }
4917                                                         }
4918                                                     }
4919                                                 }
4920                                             }
4921                                         }
4922                                       else
4923                                         {
4924                                           if (((word >> 10) & 0x1) == 0)
4925                                             {
4926                                               if (((word >> 12) & 0x1) == 0)
4927                                                 {
4928                                                   if (((word >> 30) & 0x1) == 0)
4929                                                     {
4930                                                       /* 33222222222211111111110000000000
4931                                                          10987654321098765432109876543210
4932                                                          000001x0xx1xxxxx1000x0xxxxxxxxxx
4933                                                          asr.  */
4934                                                       return 1292;
4935                                                     }
4936                                                   else
4937                                                     {
4938                                                       if (((word >> 22) & 0x1) == 0)
4939                                                         {
4940                                                           /* 33222222222211111111110000000000
4941                                                              10987654321098765432109876543210
4942                                                              010001x0x01xxxxx1000x0xxxxxxxxxx
4943                                                              smlalb.  */
4944                                                           return 2145;
4945                                                         }
4946                                                       else
4947                                                         {
4948                                                           /* 33222222222211111111110000000000
4949                                                              10987654321098765432109876543210
4950                                                              010001x0x11xxxxx1000x0xxxxxxxxxx
4951                                                              smlalb.  */
4952                                                           return 2146;
4953                                                         }
4954                                                     }
4955                                                 }
4956                                               else
4957                                                 {
4958                                                   if (((word >> 30) & 0x1) == 0)
4959                                                     {
4960                                                       /* 33222222222211111111110000000000
4961                                                          10987654321098765432109876543210
4962                                                          000001x0xx1xxxxx1001x0xxxxxxxxxx
4963                                                          asr.  */
4964                                                       return 1293;
4965                                                     }
4966                                                   else
4967                                                     {
4968                                                       if (((word >> 22) & 0x1) == 0)
4969                                                         {
4970                                                           /* 33222222222211111111110000000000
4971                                                              10987654321098765432109876543210
4972                                                              010001x0x01xxxxx1001x0xxxxxxxxxx
4973                                                              umlalb.  */
4974                                                           return 2270;
4975                                                         }
4976                                                       else
4977                                                         {
4978                                                           /* 33222222222211111111110000000000
4979                                                              10987654321098765432109876543210
4980                                                              010001x0x11xxxxx1001x0xxxxxxxxxx
4981                                                              umlalb.  */
4982                                                           return 2271;
4983                                                         }
4984                                                     }
4985                                                 }
4986                                             }
4987                                           else
4988                                             {
4989                                               if (((word >> 12) & 0x1) == 0)
4990                                                 {
4991                                                   if (((word >> 30) & 0x1) == 0)
4992                                                     {
4993                                                       if (((word >> 11) & 0x1) == 0)
4994                                                         {
4995                                                           /* 33222222222211111111110000000000
4996                                                              10987654321098765432109876543210
4997                                                              000001x0xx1xxxxx100001xxxxxxxxxx
4998                                                              lsr.  */
4999                                                           return 1736;
5000                                                         }
5001                                                       else
5002                                                         {
5003                                                           /* 33222222222211111111110000000000
5004                                                              10987654321098765432109876543210
5005                                                              000001x0xx1xxxxx100011xxxxxxxxxx
5006                                                              lsl.  */
5007                                                           return 1730;
5008                                                         }
5009                                                     }
5010                                                   else
5011                                                     {
5012                                                       if (((word >> 22) & 0x1) == 0)
5013                                                         {
5014                                                           /* 33222222222211111111110000000000
5015                                                              10987654321098765432109876543210
5016                                                              010001x0x01xxxxx1000x1xxxxxxxxxx
5017                                                              smlalt.  */
5018                                                           return 2148;
5019                                                         }
5020                                                       else
5021                                                         {
5022                                                           /* 33222222222211111111110000000000
5023                                                              10987654321098765432109876543210
5024                                                              010001x0x11xxxxx1000x1xxxxxxxxxx
5025                                                              smlalt.  */
5026                                                           return 2149;
5027                                                         }
5028                                                     }
5029                                                 }
5030                                               else
5031                                                 {
5032                                                   if (((word >> 30) & 0x1) == 0)
5033                                                     {
5034                                                       if (((word >> 11) & 0x1) == 0)
5035                                                         {
5036                                                           /* 33222222222211111111110000000000
5037                                                              10987654321098765432109876543210
5038                                                              000001x0xx1xxxxx100101xxxxxxxxxx
5039                                                              lsr.  */
5040                                                           return 1737;
5041                                                         }
5042                                                       else
5043                                                         {
5044                                                           /* 33222222222211111111110000000000
5045                                                              10987654321098765432109876543210
5046                                                              000001x0xx1xxxxx100111xxxxxxxxxx
5047                                                              lsl.  */
5048                                                           return 1731;
5049                                                         }
5050                                                     }
5051                                                   else
5052                                                     {
5053                                                       if (((word >> 22) & 0x1) == 0)
5054                                                         {
5055                                                           /* 33222222222211111111110000000000
5056                                                              10987654321098765432109876543210
5057                                                              010001x0x01xxxxx1001x1xxxxxxxxxx
5058                                                              umlalt.  */
5059                                                           return 2273;
5060                                                         }
5061                                                       else
5062                                                         {
5063                                                           /* 33222222222211111111110000000000
5064                                                              10987654321098765432109876543210
5065                                                              010001x0x11xxxxx1001x1xxxxxxxxxx
5066                                                              umlalt.  */
5067                                                           return 2274;
5068                                                         }
5069                                                     }
5070                                                 }
5071                                             }
5072                                         }
5073                                     }
5074                                   else
5075                                     {
5076                                       if (((word >> 22) & 0x1) == 0)
5077                                         {
5078                                           if (((word >> 21) & 0x1) == 0)
5079                                             {
5080                                               if (((word >> 23) & 0x1) == 0)
5081                                                 {
5082                                                   /* 33222222222211111111110000000000
5083                                                      10987654321098765432109876543210
5084                                                      1x0001x0000xxxxx100xxxxxxxxxxxxx
5085                                                      ldnt1sb.  */
5086                                                   return 2097;
5087                                                 }
5088                                               else
5089                                                 {
5090                                                   /* 33222222222211111111110000000000
5091                                                      10987654321098765432109876543210
5092                                                      1x0001x0100xxxxx100xxxxxxxxxxxxx
5093                                                      ldnt1sh.  */
5094                                                   return 2098;
5095                                                 }
5096                                             }
5097                                           else
5098                                             {
5099                                               if (((word >> 23) & 0x1) == 0)
5100                                                 {
5101                                                   if (((word >> 30) & 0x1) == 0)
5102                                                     {
5103                                                       /* 33222222222211111111110000000000
5104                                                          10987654321098765432109876543210
5105                                                          100001x0001xxxxx100xxxxxxxxxxxxx
5106                                                          ld1sb.  */
5107                                                       return 1568;
5108                                                     }
5109                                                   else
5110                                                     {
5111                                                       /* 33222222222211111111110000000000
5112                                                          10987654321098765432109876543210
5113                                                          110001x0001xxxxx100xxxxxxxxxxxxx
5114                                                          ld1sb.  */
5115                                                       return 1572;
5116                                                     }
5117                                                 }
5118                                               else
5119                                                 {
5120                                                   if (((word >> 30) & 0x1) == 0)
5121                                                     {
5122                                                       /* 33222222222211111111110000000000
5123                                                          10987654321098765432109876543210
5124                                                          100001x0101xxxxx100xxxxxxxxxxxxx
5125                                                          ld1sh.  */
5126                                                       return 1581;
5127                                                     }
5128                                                   else
5129                                                     {
5130                                                       /* 33222222222211111111110000000000
5131                                                          10987654321098765432109876543210
5132                                                          110001x0101xxxxx100xxxxxxxxxxxxx
5133                                                          ld1sh.  */
5134                                                       return 1584;
5135                                                     }
5136                                                 }
5137                                             }
5138                                         }
5139                                       else
5140                                         {
5141                                           if (((word >> 23) & 0x1) == 0)
5142                                             {
5143                                               if (((word >> 30) & 0x1) == 0)
5144                                                 {
5145                                                   /* 33222222222211111111110000000000
5146                                                      10987654321098765432109876543210
5147                                                      100001x001xxxxxx100xxxxxxxxxxxxx
5148                                                      ld1rb.  */
5149                                                   return 1538;
5150                                                 }
5151                                               else
5152                                                 {
5153                                                   if (((word >> 21) & 0x1) == 0)
5154                                                     {
5155                                                       /* 33222222222211111111110000000000
5156                                                          10987654321098765432109876543210
5157                                                          110001x0010xxxxx100xxxxxxxxxxxxx
5158                                                          ld1sb.  */
5159                                                       return 1567;
5160                                                     }
5161                                                   else
5162                                                     {
5163                                                       /* 33222222222211111111110000000000
5164                                                          10987654321098765432109876543210
5165                                                          110001x0011xxxxx100xxxxxxxxxxxxx
5166                                                          prfb.  */
5167                                                       return 1770;
5168                                                     }
5169                                                 }
5170                                             }
5171                                           else
5172                                             {
5173                                               if (((word >> 30) & 0x1) == 0)
5174                                                 {
5175                                                   /* 33222222222211111111110000000000
5176                                                      10987654321098765432109876543210
5177                                                      100001x011xxxxxx100xxxxxxxxxxxxx
5178                                                      ld1rsw.  */
5179                                                   return 1559;
5180                                                 }
5181                                               else
5182                                                 {
5183                                                   if (((word >> 21) & 0x1) == 0)
5184                                                     {
5185                                                       /* 33222222222211111111110000000000
5186                                                          10987654321098765432109876543210
5187                                                          110001x0110xxxxx100xxxxxxxxxxxxx
5188                                                          ld1sh.  */
5189                                                       return 1579;
5190                                                     }
5191                                                   else
5192                                                     {
5193                                                       /* 33222222222211111111110000000000
5194                                                          10987654321098765432109876543210
5195                                                          110001x0111xxxxx100xxxxxxxxxxxxx
5196                                                          ld1sh.  */
5197                                                       return 1580;
5198                                                     }
5199                                                 }
5200                                             }
5201                                         }
5202                                     }
5203                                 }
5204                             }
5205                           else
5206                             {
5207                               if (((word >> 15) & 0x1) == 0)
5208                                 {
5209                                   if (((word >> 21) & 0x1) == 0)
5210                                     {
5211                                       if (((word >> 30) & 0x1) == 0)
5212                                         {
5213                                           if (((word >> 31) & 0x1) == 0)
5214                                             {
5215                                               /* 33222222222211111111110000000000
5216                                                  10987654321098765432109876543210
5217                                                  000001x0xx0xxxxx010xxxxxxxxxxxxx
5218                                                  mla.  */
5219                                               return 1743;
5220                                             }
5221                                           else
5222                                             {
5223                                               if (((word >> 23) & 0x1) == 0)
5224                                                 {
5225                                                   /* 33222222222211111111110000000000
5226                                                      10987654321098765432109876543210
5227                                                      100001x00x0xxxxx010xxxxxxxxxxxxx
5228                                                      ld1b.  */
5229                                                   return 1504;
5230                                                 }
5231                                               else
5232                                                 {
5233                                                   /* 33222222222211111111110000000000
5234                                                      10987654321098765432109876543210
5235                                                      100001x01x0xxxxx010xxxxxxxxxxxxx
5236                                                      ld1h.  */
5237                                                   return 1524;
5238                                                 }
5239                                             }
5240                                         }
5241                                       else
5242                                         {
5243                                           if (((word >> 31) & 0x1) == 0)
5244                                             {
5245                                               if (((word >> 10) & 0x1) == 0)
5246                                                 {
5247                                                   if (((word >> 11) & 0x1) == 0)
5248                                                     {
5249                                                       if (((word >> 12) & 0x1) == 0)
5250                                                         {
5251                                                           /* 33222222222211111111110000000000
5252                                                              10987654321098765432109876543210
5253                                                              010001x0xx0xxxxx010000xxxxxxxxxx
5254                                                              smlalb.  */
5255                                                           return 2147;
5256                                                         }
5257                                                       else
5258                                                         {
5259                                                           /* 33222222222211111111110000000000
5260                                                              10987654321098765432109876543210
5261                                                              010001x0xx0xxxxx010100xxxxxxxxxx
5262                                                              smlslb.  */
5263                                                           return 2153;
5264                                                         }
5265                                                     }
5266                                                   else
5267                                                     {
5268                                                       if (((word >> 12) & 0x1) == 0)
5269                                                         {
5270                                                           /* 33222222222211111111110000000000
5271                                                              10987654321098765432109876543210
5272                                                              010001x0xx0xxxxx010010xxxxxxxxxx
5273                                                              umlalb.  */
5274                                                           return 2272;
5275                                                         }
5276                                                       else
5277                                                         {
5278                                                           /* 33222222222211111111110000000000
5279                                                              10987654321098765432109876543210
5280                                                              010001x0xx0xxxxx010110xxxxxxxxxx
5281                                                              umlslb.  */
5282                                                           return 2278;
5283                                                         }
5284                                                     }
5285                                                 }
5286                                               else
5287                                                 {
5288                                                   if (((word >> 11) & 0x1) == 0)
5289                                                     {
5290                                                       if (((word >> 12) & 0x1) == 0)
5291                                                         {
5292                                                           /* 33222222222211111111110000000000
5293                                                              10987654321098765432109876543210
5294                                                              010001x0xx0xxxxx010001xxxxxxxxxx
5295                                                              smlalt.  */
5296                                                           return 2150;
5297                                                         }
5298                                                       else
5299                                                         {
5300                                                           /* 33222222222211111111110000000000
5301                                                              10987654321098765432109876543210
5302                                                              010001x0xx0xxxxx010101xxxxxxxxxx
5303                                                              smlslt.  */
5304                                                           return 2156;
5305                                                         }
5306                                                     }
5307                                                   else
5308                                                     {
5309                                                       if (((word >> 12) & 0x1) == 0)
5310                                                         {
5311                                                           /* 33222222222211111111110000000000
5312                                                              10987654321098765432109876543210
5313                                                              010001x0xx0xxxxx010011xxxxxxxxxx
5314                                                              umlalt.  */
5315                                                           return 2275;
5316                                                         }
5317                                                       else
5318                                                         {
5319                                                           /* 33222222222211111111110000000000
5320                                                              10987654321098765432109876543210
5321                                                              010001x0xx0xxxxx010111xxxxxxxxxx
5322                                                              umlslt.  */
5323                                                           return 2281;
5324                                                         }
5325                                                     }
5326                                                 }
5327                                             }
5328                                           else
5329                                             {
5330                                               if (((word >> 23) & 0x1) == 0)
5331                                                 {
5332                                                   /* 33222222222211111111110000000000
5333                                                      10987654321098765432109876543210
5334                                                      110001x00x0xxxxx010xxxxxxxxxxxxx
5335                                                      ld1b.  */
5336                                                   return 1509;
5337                                                 }
5338                                               else
5339                                                 {
5340                                                   /* 33222222222211111111110000000000
5341                                                      10987654321098765432109876543210
5342                                                      110001x01x0xxxxx010xxxxxxxxxxxxx
5343                                                      ld1h.  */
5344                                                   return 1529;
5345                                                 }
5346                                             }
5347                                         }
5348                                     }
5349                                   else
5350                                     {
5351                                       if (((word >> 30) & 0x1) == 0)
5352                                         {
5353                                           if (((word >> 31) & 0x1) == 0)
5354                                             {
5355                                               if (((word >> 11) & 0x1) == 0)
5356                                                 {
5357                                                   if (((word >> 12) & 0x1) == 0)
5358                                                     {
5359                                                       if (((word >> 10) & 0x1) == 0)
5360                                                         {
5361                                                           /* 33222222222211111111110000000000
5362                                                              10987654321098765432109876543210
5363                                                              000001x0xx1xxxxx010000xxxxxxxxxx
5364                                                              index.  */
5365                                                           return 1495;
5366                                                         }
5367                                                       else
5368                                                         {
5369                                                           /* 33222222222211111111110000000000
5370                                                              10987654321098765432109876543210
5371                                                              000001x0xx1xxxxx010001xxxxxxxxxx
5372                                                              index.  */
5373                                                           return 1496;
5374                                                         }
5375                                                     }
5376                                                   else
5377                                                     {
5378                                                       if (((word >> 22) & 0x1) == 0)
5379                                                         {
5380                                                           if (((word >> 23) & 0x1) == 0)
5381                                                             {
5382                                                               /* 33222222222211111111110000000000
5383                                                                  10987654321098765432109876543210
5384                                                                  000001x0001xxxxx01010xxxxxxxxxxx
5385                                                                  addvl.  */
5386                                                               return 1282;
5387                                                             }
5388                                                           else
5389                                                             {
5390                                                               /* 33222222222211111111110000000000
5391                                                                  10987654321098765432109876543210
5392                                                                  000001x0101xxxxx01010xxxxxxxxxxx
5393                                                                  rdvl.  */
5394                                                               return 1804;
5395                                                             }
5396                                                         }
5397                                                       else
5398                                                         {
5399                                                           /* 33222222222211111111110000000000
5400                                                              10987654321098765432109876543210
5401                                                              000001x0x11xxxxx01010xxxxxxxxxxx
5402                                                              addpl.  */
5403                                                           return 1281;
5404                                                         }
5405                                                     }
5406                                                 }
5407                                               else
5408                                                 {
5409                                                   if (((word >> 10) & 0x1) == 0)
5410                                                     {
5411                                                       /* 33222222222211111111110000000000
5412                                                          10987654321098765432109876543210
5413                                                          000001x0xx1xxxxx010x10xxxxxxxxxx
5414                                                          index.  */
5415                                                       return 1497;
5416                                                     }
5417                                                   else
5418                                                     {
5419                                                       /* 33222222222211111111110000000000
5420                                                          10987654321098765432109876543210
5421                                                          000001x0xx1xxxxx010x11xxxxxxxxxx
5422                                                          index.  */
5423                                                       return 1494;
5424                                                     }
5425                                                 }
5426                                             }
5427                                           else
5428                                             {
5429                                               if (((word >> 23) & 0x1) == 0)
5430                                                 {
5431                                                   /* 33222222222211111111110000000000
5432                                                      10987654321098765432109876543210
5433                                                      100001x00x1xxxxx010xxxxxxxxxxxxx
5434                                                      prfw.  */
5435                                                   return 1788;
5436                                                 }
5437                                               else
5438                                                 {
5439                                                   /* 33222222222211111111110000000000
5440                                                      10987654321098765432109876543210
5441                                                      100001x01x1xxxxx010xxxxxxxxxxxxx
5442                                                      ld1h.  */
5443                                                   return 1525;
5444                                                 }
5445                                             }
5446                                         }
5447                                       else
5448                                         {
5449                                           if (((word >> 23) & 0x1) == 0)
5450                                             {
5451                                               /* 33222222222211111111110000000000
5452                                                  10987654321098765432109876543210
5453                                                  x10001x00x1xxxxx010xxxxxxxxxxxxx
5454                                                  prfw.  */
5455                                               return 1790;
5456                                             }
5457                                           else
5458                                             {
5459                                               if (((word >> 31) & 0x1) == 0)
5460                                                 {
5461                                                   if (((word >> 22) & 0x1) == 0)
5462                                                     {
5463                                                       /* 33222222222211111111110000000000
5464                                                          10987654321098765432109876543210
5465                                                          010001x0101xxxxx010xxxxxxxxxxxxx
5466                                                          cdot.  */
5467                                                       return 2062;
5468                                                     }
5469                                                   else
5470                                                     {
5471                                                       /* 33222222222211111111110000000000
5472                                                          10987654321098765432109876543210
5473                                                          010001x0111xxxxx010xxxxxxxxxxxxx
5474                                                          cdot.  */
5475                                                       return 2061;
5476                                                     }
5477                                                 }
5478                                               else
5479                                                 {
5480                                                   /* 33222222222211111111110000000000
5481                                                      10987654321098765432109876543210
5482                                                      110001x01x1xxxxx010xxxxxxxxxxxxx
5483                                                      ld1h.  */
5484                                                   return 1530;
5485                                                 }
5486                                             }
5487                                         }
5488                                     }
5489                                 }
5490                               else
5491                                 {
5492                                   if (((word >> 30) & 0x1) == 0)
5493                                     {
5494                                       if (((word >> 31) & 0x1) == 0)
5495                                         {
5496                                           if (((word >> 21) & 0x1) == 0)
5497                                             {
5498                                               /* 33222222222211111111110000000000
5499                                                  10987654321098765432109876543210
5500                                                  000001x0xx0xxxxx110xxxxxxxxxxxxx
5501                                                  mad.  */
5502                                               return 1742;
5503                                             }
5504                                           else
5505                                             {
5506                                               if (((word >> 10) & 0x1) == 0)
5507                                                 {
5508                                                   if (((word >> 11) & 0x1) == 0)
5509                                                     {
5510                                                       if (((word >> 20) & 0x1) == 0)
5511                                                         {
5512                                                           if (((word >> 22) & 0x1) == 0)
5513                                                             {
5514                                                               /* 33222222222211111111110000000000
5515                                                                  10987654321098765432109876543210
5516                                                                  000001x0x010xxxx110x00xxxxxxxxxx
5517                                                                  sqincw.  */
5518                                                               return 1862;
5519                                                             }
5520                                                           else
5521                                                             {
5522                                                               if (((word >> 23) & 0x1) == 0)
5523                                                                 {
5524                                                                   /* 33222222222211111111110000000000
5525                                                                      10987654321098765432109876543210
5526                                                                      000001x00110xxxx110x00xxxxxxxxxx
5527                                                                      sqinch.  */
5528                                                                   return 1856;
5529                                                                 }
5530                                                               else
5531                                                                 {
5532                                                                   /* 33222222222211111111110000000000
5533                                                                      10987654321098765432109876543210
5534                                                                      000001x01110xxxx110x00xxxxxxxxxx
5535                                                                      sqincd.  */
5536                                                                   return 1853;
5537                                                                 }
5538                                                             }
5539                                                         }
5540                                                       else
5541                                                         {
5542                                                           if (((word >> 22) & 0x1) == 0)
5543                                                             {
5544                                                               /* 33222222222211111111110000000000
5545                                                                  10987654321098765432109876543210
5546                                                                  000001x0x011xxxx110x00xxxxxxxxxx
5547                                                                  incw.  */
5548                                                               return 1492;
5549                                                             }
5550                                                           else
5551                                                             {
5552                                                               if (((word >> 23) & 0x1) == 0)
5553                                                                 {
5554                                                                   /* 33222222222211111111110000000000
5555                                                                      10987654321098765432109876543210
5556                                                                      000001x00111xxxx110x00xxxxxxxxxx
5557                                                                      inch.  */
5558                                                                   return 1488;
5559                                                                 }
5560                                                               else
5561                                                                 {
5562                                                                   /* 33222222222211111111110000000000
5563                                                                      10987654321098765432109876543210
5564                                                                      000001x01111xxxx110x00xxxxxxxxxx
5565                                                                      incd.  */
5566                                                                   return 1486;
5567                                                                 }
5568                                                             }
5569                                                         }
5570                                                     }
5571                                                   else
5572                                                     {
5573                                                       if (((word >> 22) & 0x1) == 0)
5574                                                         {
5575                                                           /* 33222222222211111111110000000000
5576                                                              10987654321098765432109876543210
5577                                                              000001x0x01xxxxx110x10xxxxxxxxxx
5578                                                              sqdecw.  */
5579                                                           return 1848;
5580                                                         }
5581                                                       else
5582                                                         {
5583                                                           if (((word >> 23) & 0x1) == 0)
5584                                                             {
5585                                                               /* 33222222222211111111110000000000
5586                                                                  10987654321098765432109876543210
5587                                                                  000001x0011xxxxx110x10xxxxxxxxxx
5588                                                                  sqdech.  */
5589                                                               return 1842;
5590                                                             }
5591                                                           else
5592                                                             {
5593                                                               /* 33222222222211111111110000000000
5594                                                                  10987654321098765432109876543210
5595                                                                  000001x0111xxxxx110x10xxxxxxxxxx
5596                                                                  sqdecd.  */
5597                                                               return 1839;
5598                                                             }
5599                                                         }
5600                                                     }
5601                                                 }
5602                                               else
5603                                                 {
5604                                                   if (((word >> 11) & 0x1) == 0)
5605                                                     {
5606                                                       if (((word >> 20) & 0x1) == 0)
5607                                                         {
5608                                                           if (((word >> 22) & 0x1) == 0)
5609                                                             {
5610                                                               /* 33222222222211111111110000000000
5611                                                                  10987654321098765432109876543210
5612                                                                  000001x0x010xxxx110x01xxxxxxxxxx
5613                                                                  uqincw.  */
5614                                                               return 2010;
5615                                                             }
5616                                                           else
5617                                                             {
5618                                                               if (((word >> 23) & 0x1) == 0)
5619                                                                 {
5620                                                                   /* 33222222222211111111110000000000
5621                                                                      10987654321098765432109876543210
5622                                                                      000001x00110xxxx110x01xxxxxxxxxx
5623                                                                      uqinch.  */
5624                                                                   return 2004;
5625                                                                 }
5626                                                               else
5627                                                                 {
5628                                                                   /* 33222222222211111111110000000000
5629                                                                      10987654321098765432109876543210
5630                                                                      000001x01110xxxx110x01xxxxxxxxxx
5631                                                                      uqincd.  */
5632                                                                   return 2001;
5633                                                                 }
5634                                                             }
5635                                                         }
5636                                                       else
5637                                                         {
5638                                                           if (((word >> 22) & 0x1) == 0)
5639                                                             {
5640                                                               /* 33222222222211111111110000000000
5641                                                                  10987654321098765432109876543210
5642                                                                  000001x0x011xxxx110x01xxxxxxxxxx
5643                                                                  decw.  */
5644                                                               return 1367;
5645                                                             }
5646                                                           else
5647                                                             {
5648                                                               if (((word >> 23) & 0x1) == 0)
5649                                                                 {
5650                                                                   /* 33222222222211111111110000000000
5651                                                                      10987654321098765432109876543210
5652                                                                      000001x00111xxxx110x01xxxxxxxxxx
5653                                                                      dech.  */
5654                                                                   return 1363;
5655                                                                 }
5656                                                               else
5657                                                                 {
5658                                                                   /* 33222222222211111111110000000000
5659                                                                      10987654321098765432109876543210
5660                                                                      000001x01111xxxx110x01xxxxxxxxxx
5661                                                                      decd.  */
5662                                                                   return 1361;
5663                                                                 }
5664                                                             }
5665                                                         }
5666                                                     }
5667                                                   else
5668                                                     {
5669                                                       if (((word >> 22) & 0x1) == 0)
5670                                                         {
5671                                                           /* 33222222222211111111110000000000
5672                                                              10987654321098765432109876543210
5673                                                              000001x0x01xxxxx110x11xxxxxxxxxx
5674                                                              uqdecw.  */
5675                                                           return 1996;
5676                                                         }
5677                                                       else
5678                                                         {
5679                                                           if (((word >> 23) & 0x1) == 0)
5680                                                             {
5681                                                               /* 33222222222211111111110000000000
5682                                                                  10987654321098765432109876543210
5683                                                                  000001x0011xxxxx110x11xxxxxxxxxx
5684                                                                  uqdech.  */
5685                                                               return 1990;
5686                                                             }
5687                                                           else
5688                                                             {
5689                                                               /* 33222222222211111111110000000000
5690                                                                  10987654321098765432109876543210
5691                                                                  000001x0111xxxxx110x11xxxxxxxxxx
5692                                                                  uqdecd.  */
5693                                                               return 1987;
5694                                                             }
5695                                                         }
5696                                                     }
5697                                                 }
5698                                             }
5699                                         }
5700                                       else
5701                                         {
5702                                           if (((word >> 22) & 0x1) == 0)
5703                                             {
5704                                               if (((word >> 21) & 0x1) == 0)
5705                                                 {
5706                                                   if (((word >> 23) & 0x1) == 0)
5707                                                     {
5708                                                       /* 33222222222211111111110000000000
5709                                                          10987654321098765432109876543210
5710                                                          100001x0000xxxxx110xxxxxxxxxxxxx
5711                                                          prfb.  */
5712                                                       return 1767;
5713                                                     }
5714                                                   else
5715                                                     {
5716                                                       /* 33222222222211111111110000000000
5717                                                          10987654321098765432109876543210
5718                                                          100001x0100xxxxx110xxxxxxxxxxxxx
5719                                                          prfh.  */
5720                                                       return 1782;
5721                                                     }
5722                                                 }
5723                                               else
5724                                                 {
5725                                                   if (((word >> 23) & 0x1) == 0)
5726                                                     {
5727                                                       /* 33222222222211111111110000000000
5728                                                          10987654321098765432109876543210
5729                                                          100001x0001xxxxx110xxxxxxxxxxxxx
5730                                                          ld1b.  */
5731                                                       return 1511;
5732                                                     }
5733                                                   else
5734                                                     {
5735                                                       /* 33222222222211111111110000000000
5736                                                          10987654321098765432109876543210
5737                                                          100001x0101xxxxx110xxxxxxxxxxxxx
5738                                                          ld1h.  */
5739                                                       return 1533;
5740                                                     }
5741                                                 }
5742                                             }
5743                                           else
5744                                             {
5745                                               if (((word >> 23) & 0x1) == 0)
5746                                                 {
5747                                                   /* 33222222222211111111110000000000
5748                                                      10987654321098765432109876543210
5749                                                      100001x001xxxxxx110xxxxxxxxxxxxx
5750                                                      ld1rb.  */
5751                                                   return 1540;
5752                                                 }
5753                                               else
5754                                                 {
5755                                                   /* 33222222222211111111110000000000
5756                                                      10987654321098765432109876543210
5757                                                      100001x011xxxxxx110xxxxxxxxxxxxx
5758                                                      ld1rh.  */
5759                                                   return 1544;
5760                                                 }
5761                                             }
5762                                         }
5763                                     }
5764                                   else
5765                                     {
5766                                       if (((word >> 21) & 0x1) == 0)
5767                                         {
5768                                           if (((word >> 22) & 0x1) == 0)
5769                                             {
5770                                               if (((word >> 23) & 0x1) == 0)
5771                                                 {
5772                                                   /* 33222222222211111111110000000000
5773                                                      10987654321098765432109876543210
5774                                                      x10001x0000xxxxx110xxxxxxxxxxxxx
5775                                                      ldnt1b.  */
5776                                                   return 2093;
5777                                                 }
5778                                               else
5779                                                 {
5780                                                   /* 33222222222211111111110000000000
5781                                                      10987654321098765432109876543210
5782                                                      x10001x0100xxxxx110xxxxxxxxxxxxx
5783                                                      ldnt1h.  */
5784                                                   return 2096;
5785                                                 }
5786                                             }
5787                                           else
5788                                             {
5789                                               if (((word >> 23) & 0x1) == 0)
5790                                                 {
5791                                                   /* 33222222222211111111110000000000
5792                                                      10987654321098765432109876543210
5793                                                      x10001x0010xxxxx110xxxxxxxxxxxxx
5794                                                      ld1b.  */
5795                                                   return 1510;
5796                                                 }
5797                                               else
5798                                                 {
5799                                                   /* 33222222222211111111110000000000
5800                                                      10987654321098765432109876543210
5801                                                      x10001x0110xxxxx110xxxxxxxxxxxxx
5802                                                      ld1h.  */
5803                                                   return 1531;
5804                                                 }
5805                                             }
5806                                         }
5807                                       else
5808                                         {
5809                                           if (((word >> 22) & 0x1) == 0)
5810                                             {
5811                                               if (((word >> 23) & 0x1) == 0)
5812                                                 {
5813                                                   /* 33222222222211111111110000000000
5814                                                      10987654321098765432109876543210
5815                                                      x10001x0001xxxxx110xxxxxxxxxxxxx
5816                                                      ld1b.  */
5817                                                   return 1516;
5818                                                 }
5819                                               else
5820                                                 {
5821                                                   if (((word >> 31) & 0x1) == 0)
5822                                                     {
5823                                                       if (((word >> 10) & 0x1) == 0)
5824                                                         {
5825                                                           if (((word >> 12) & 0x1) == 0)
5826                                                             {
5827                                                               /* 33222222222211111111110000000000
5828                                                                  10987654321098765432109876543210
5829                                                                  010001x0101xxxxx1100x0xxxxxxxxxx
5830                                                                  smullb.  */
5831                                                               return 2158;
5832                                                             }
5833                                                           else
5834                                                             {
5835                                                               /* 33222222222211111111110000000000
5836                                                                  10987654321098765432109876543210
5837                                                                  010001x0101xxxxx1101x0xxxxxxxxxx
5838                                                                  umullb.  */
5839                                                               return 2283;
5840                                                             }
5841                                                         }
5842                                                       else
5843                                                         {
5844                                                           if (((word >> 12) & 0x1) == 0)
5845                                                             {
5846                                                               /* 33222222222211111111110000000000
5847                                                                  10987654321098765432109876543210
5848                                                                  010001x0101xxxxx1100x1xxxxxxxxxx
5849                                                                  smullt.  */
5850                                                               return 2161;
5851                                                             }
5852                                                           else
5853                                                             {
5854                                                               /* 33222222222211111111110000000000
5855                                                                  10987654321098765432109876543210
5856                                                                  010001x0101xxxxx1101x1xxxxxxxxxx
5857                                                                  umullt.  */
5858                                                               return 2286;
5859                                                             }
5860                                                         }
5861                                                     }
5862                                                   else
5863                                                     {
5864                                                       /* 33222222222211111111110000000000
5865                                                          10987654321098765432109876543210
5866                                                          110001x0101xxxxx110xxxxxxxxxxxxx
5867                                                          ld1h.  */
5868                                                       return 1537;
5869                                                     }
5870                                                 }
5871                                             }
5872                                           else
5873                                             {
5874                                               if (((word >> 23) & 0x1) == 0)
5875                                                 {
5876                                                   /* 33222222222211111111110000000000
5877                                                      10987654321098765432109876543210
5878                                                      x10001x0011xxxxx110xxxxxxxxxxxxx
5879                                                      prfw.  */
5880                                                   return 1791;
5881                                                 }
5882                                               else
5883                                                 {
5884                                                   if (((word >> 31) & 0x1) == 0)
5885                                                     {
5886                                                       if (((word >> 10) & 0x1) == 0)
5887                                                         {
5888                                                           if (((word >> 12) & 0x1) == 0)
5889                                                             {
5890                                                               /* 33222222222211111111110000000000
5891                                                                  10987654321098765432109876543210
5892                                                                  010001x0111xxxxx1100x0xxxxxxxxxx
5893                                                                  smullb.  */
5894                                                               return 2159;
5895                                                             }
5896                                                           else
5897                                                             {
5898                                                               /* 33222222222211111111110000000000
5899                                                                  10987654321098765432109876543210
5900                                                                  010001x0111xxxxx1101x0xxxxxxxxxx
5901                                                                  umullb.  */
5902                                                               return 2284;
5903                                                             }
5904                                                         }
5905                                                       else
5906                                                         {
5907                                                           if (((word >> 12) & 0x1) == 0)
5908                                                             {
5909                                                               /* 33222222222211111111110000000000
5910                                                                  10987654321098765432109876543210
5911                                                                  010001x0111xxxxx1100x1xxxxxxxxxx
5912                                                                  smullt.  */
5913                                                               return 2162;
5914                                                             }
5915                                                           else
5916                                                             {
5917                                                               /* 33222222222211111111110000000000
5918                                                                  10987654321098765432109876543210
5919                                                                  010001x0111xxxxx1101x1xxxxxxxxxx
5920                                                                  umullt.  */
5921                                                               return 2287;
5922                                                             }
5923                                                         }
5924                                                     }
5925                                                   else
5926                                                     {
5927                                                       /* 33222222222211111111110000000000
5928                                                          10987654321098765432109876543210
5929                                                          110001x0111xxxxx110xxxxxxxxxxxxx
5930                                                          ld1h.  */
5931                                                       return 1532;
5932                                                     }
5933                                                 }
5934                                             }
5935                                         }
5936                                     }
5937                                 }
5938                             }
5939                         }
5940                       else
5941                         {
5942                           if (((word >> 14) & 0x1) == 0)
5943                             {
5944                               if (((word >> 15) & 0x1) == 0)
5945                                 {
5946                                   if (((word >> 21) & 0x1) == 0)
5947                                     {
5948                                       if (((word >> 30) & 0x1) == 0)
5949                                         {
5950                                           if (((word >> 31) & 0x1) == 0)
5951                                             {
5952                                               if (((word >> 17) & 0x1) == 0)
5953                                                 {
5954                                                   if (((word >> 19) & 0x1) == 0)
5955                                                     {
5956                                                       if (((word >> 20) & 0x1) == 0)
5957                                                         {
5958                                                           if (((word >> 16) & 0x1) == 0)
5959                                                             {
5960                                                               /* 33222222222211111111110000000000
5961                                                                  10987654321098765432109876543210
5962                                                                  000001x0xx000x00001xxxxxxxxxxxxx
5963                                                                  saddv.  */
5964                                                               return 1811;
5965                                                             }
5966                                                           else
5967                                                             {
5968                                                               /* 33222222222211111111110000000000
5969                                                                  10987654321098765432109876543210
5970                                                                  000001x0xx000x01001xxxxxxxxxxxxx
5971                                                                  uaddv.  */
5972                                                               return 1963;
5973                                                             }
5974                                                         }
5975                                                       else
5976                                                         {
5977                                                           /* 33222222222211111111110000000000
5978                                                              10987654321098765432109876543210
5979                                                              000001x0xx010x0x001xxxxxxxxxxxxx
5980                                                              movprfx.  */
5981                                                           return 1746;
5982                                                         }
5983                                                     }
5984                                                   else
5985                                                     {
5986                                                       if (((word >> 16) & 0x1) == 0)
5987                                                         {
5988                                                           if (((word >> 20) & 0x1) == 0)
5989                                                             {
5990                                                               /* 33222222222211111111110000000000
5991                                                                  10987654321098765432109876543210
5992                                                                  000001x0xx001x00001xxxxxxxxxxxxx
5993                                                                  smaxv.  */
5994                                                               return 1829;
5995                                                             }
5996                                                           else
5997                                                             {
5998                                                               /* 33222222222211111111110000000000
5999                                                                  10987654321098765432109876543210
6000                                                                  000001x0xx011x00001xxxxxxxxxxxxx
6001                                                                  orv.  */
6002                                                               return 1763;
6003                                                             }
6004                                                         }
6005                                                       else
6006                                                         {
6007                                                           if (((word >> 20) & 0x1) == 0)
6008                                                             {
6009                                                               /* 33222222222211111111110000000000
6010                                                                  10987654321098765432109876543210
6011                                                                  000001x0xx001x01001xxxxxxxxxxxxx
6012                                                                  umaxv.  */
6013                                                               return 1978;
6014                                                             }
6015                                                           else
6016                                                             {
6017                                                               /* 33222222222211111111110000000000
6018                                                                  10987654321098765432109876543210
6019                                                                  000001x0xx011x01001xxxxxxxxxxxxx
6020                                                                  eorv.  */
6021                                                               return 1378;
6022                                                             }
6023                                                         }
6024                                                     }
6025                                                 }
6026                                               else
6027                                                 {
6028                                                   if (((word >> 16) & 0x1) == 0)
6029                                                     {
6030                                                       if (((word >> 20) & 0x1) == 0)
6031                                                         {
6032                                                           /* 33222222222211111111110000000000
6033                                                              10987654321098765432109876543210
6034                                                              000001x0xx00xx10001xxxxxxxxxxxxx
6035                                                              sminv.  */
6036                                                           return 1832;
6037                                                         }
6038                                                       else
6039                                                         {
6040                                                           /* 33222222222211111111110000000000
6041                                                              10987654321098765432109876543210
6042                                                              000001x0xx01xx10001xxxxxxxxxxxxx
6043                                                              andv.  */
6044                                                           return 1291;
6045                                                         }
6046                                                     }
6047                                                   else
6048                                                     {
6049                                                       /* 33222222222211111111110000000000
6050                                                          10987654321098765432109876543210
6051                                                          000001x0xx0xxx11001xxxxxxxxxxxxx
6052                                                          uminv.  */
6053                                                       return 1981;
6054                                                     }
6055                                                 }
6056                                             }
6057                                           else
6058                                             {
6059                                               if (((word >> 23) & 0x1) == 0)
6060                                                 {
6061                                                   /* 33222222222211111111110000000000
6062                                                      10987654321098765432109876543210
6063                                                      100001x00x0xxxxx001xxxxxxxxxxxxx
6064                                                      ldff1sb.  */
6065                                                   return 1662;
6066                                                 }
6067                                               else
6068                                                 {
6069                                                   /* 33222222222211111111110000000000
6070                                                      10987654321098765432109876543210
6071                                                      100001x01x0xxxxx001xxxxxxxxxxxxx
6072                                                      ldff1sh.  */
6073                                                   return 1673;
6074                                                 }
6075                                             }
6076                                         }
6077                                       else
6078                                         {
6079                                           if (((word >> 31) & 0x1) == 0)
6080                                             {
6081                                               if (((word >> 12) & 0x1) == 0)
6082                                                 {
6083                                                   /* 33222222222211111111110000000000
6084                                                      10987654321098765432109876543210
6085                                                      010001x0xx0xxxxx0010xxxxxxxxxxxx
6086                                                      cmla.  */
6087                                                   return 2063;
6088                                                 }
6089                                               else
6090                                                 {
6091                                                   /* 33222222222211111111110000000000
6092                                                      10987654321098765432109876543210
6093                                                      010001x0xx0xxxxx0011xxxxxxxxxxxx
6094                                                      sqrdcmlah.  */
6095                                                   return 2195;
6096                                                 }
6097                                             }
6098                                           else
6099                                             {
6100                                               if (((word >> 23) & 0x1) == 0)
6101                                                 {
6102                                                   /* 33222222222211111111110000000000
6103                                                      10987654321098765432109876543210
6104                                                      110001x00x0xxxxx001xxxxxxxxxxxxx
6105                                                      ldff1sb.  */
6106                                                   return 1669;
6107                                                 }
6108                                               else
6109                                                 {
6110                                                   /* 33222222222211111111110000000000
6111                                                      10987654321098765432109876543210
6112                                                      110001x01x0xxxxx001xxxxxxxxxxxxx
6113                                                      ldff1sh.  */
6114                                                   return 1679;
6115                                                 }
6116                                             }
6117                                         }
6118                                     }
6119                                   else
6120                                     {
6121                                       if (((word >> 30) & 0x1) == 0)
6122                                         {
6123                                           if (((word >> 31) & 0x1) == 0)
6124                                             {
6125                                               if (((word >> 10) & 0x1) == 0)
6126                                                 {
6127                                                   if (((word >> 11) & 0x1) == 0)
6128                                                     {
6129                                                       if (((word >> 22) & 0x1) == 0)
6130                                                         {
6131                                                           if (((word >> 23) & 0x1) == 0)
6132                                                             {
6133                                                               /* 33222222222211111111110000000000
6134                                                                  10987654321098765432109876543210
6135                                                                  000001x0001xxxxx001x00xxxxxxxxxx
6136                                                                  and.  */
6137                                                               return 1286;
6138                                                             }
6139                                                           else
6140                                                             {
6141                                                               /* 33222222222211111111110000000000
6142                                                                  10987654321098765432109876543210
6143                                                                  000001x0101xxxxx001x00xxxxxxxxxx
6144                                                                  eor.  */
6145                                                               return 1373;
6146                                                             }
6147                                                         }
6148                                                       else
6149                                                         {
6150                                                           if (((word >> 23) & 0x1) == 0)
6151                                                             {
6152                                                               /* 33222222222211111111110000000000
6153                                                                  10987654321098765432109876543210
6154                                                                  000001x0011xxxxx001x00xxxxxxxxxx
6155                                                                  orr.  */
6156                                                               return 1758;
6157                                                             }
6158                                                           else
6159                                                             {
6160                                                               /* 33222222222211111111110000000000
6161                                                                  10987654321098765432109876543210
6162                                                                  000001x0111xxxxx001x00xxxxxxxxxx
6163                                                                  bic.  */
6164                                                               return 1299;
6165                                                             }
6166                                                         }
6167                                                     }
6168                                                   else
6169                                                     {
6170                                                       if (((word >> 22) & 0x1) == 0)
6171                                                         {
6172                                                           /* 33222222222211111111110000000000
6173                                                              10987654321098765432109876543210
6174                                                              000001x0x01xxxxx001x10xxxxxxxxxx
6175                                                              eor3.  */
6176                                                           return 2066;
6177                                                         }
6178                                                       else
6179                                                         {
6180                                                           /* 33222222222211111111110000000000
6181                                                              10987654321098765432109876543210
6182                                                              000001x0x11xxxxx001x10xxxxxxxxxx
6183                                                              bcax.  */
6184                                                           return 2055;
6185                                                         }
6186                                                     }
6187                                                 }
6188                                               else
6189                                                 {
6190                                                   if (((word >> 11) & 0x1) == 0)
6191                                                     {
6192                                                       /* 33222222222211111111110000000000
6193                                                          10987654321098765432109876543210
6194                                                          000001x0xx1xxxxx001x01xxxxxxxxxx
6195                                                          xar.  */
6196                                                       return 2328;
6197                                                     }
6198                                                   else
6199                                                     {
6200                                                       if (((word >> 22) & 0x1) == 0)
6201                                                         {
6202                                                           if (((word >> 23) & 0x1) == 0)
6203                                                             {
6204                                                               /* 33222222222211111111110000000000
6205                                                                  10987654321098765432109876543210
6206                                                                  000001x0001xxxxx001x11xxxxxxxxxx
6207                                                                  bsl.  */
6208                                                               return 2056;
6209                                                             }
6210                                                           else
6211                                                             {
6212                                                               /* 33222222222211111111110000000000
6213                                                                  10987654321098765432109876543210
6214                                                                  000001x0101xxxxx001x11xxxxxxxxxx
6215                                                                  bsl2n.  */
6216                                                               return 2058;
6217                                                             }
6218                                                         }
6219                                                       else
6220                                                         {
6221                                                           if (((word >> 23) & 0x1) == 0)
6222                                                             {
6223                                                               /* 33222222222211111111110000000000
6224                                                                  10987654321098765432109876543210
6225                                                                  000001x0011xxxxx001x11xxxxxxxxxx
6226                                                                  bsl1n.  */
6227                                                               return 2057;
6228                                                             }
6229                                                           else
6230                                                             {
6231                                                               /* 33222222222211111111110000000000
6232                                                                  10987654321098765432109876543210
6233                                                                  000001x0111xxxxx001x11xxxxxxxxxx
6234                                                                  nbsl.  */
6235                                                               return 2113;
6236                                                             }
6237                                                         }
6238                                                     }
6239                                                 }
6240                                             }
6241                                           else
6242                                             {
6243                                               if (((word >> 23) & 0x1) == 0)
6244                                                 {
6245                                                   /* 33222222222211111111110000000000
6246                                                      10987654321098765432109876543210
6247                                                      100001x00x1xxxxx001xxxxxxxxxxxxx
6248                                                      prfh.  */
6249                                                   return 1781;
6250                                                 }
6251                                               else
6252                                                 {
6253                                                   /* 33222222222211111111110000000000
6254                                                      10987654321098765432109876543210
6255                                                      100001x01x1xxxxx001xxxxxxxxxxxxx
6256                                                      ldff1sh.  */
6257                                                   return 1674;
6258                                                 }
6259                                             }
6260                                         }
6261                                       else
6262                                         {
6263                                           if (((word >> 23) & 0x1) == 0)
6264                                             {
6265                                               /* 33222222222211111111110000000000
6266                                                  10987654321098765432109876543210
6267                                                  x10001x00x1xxxxx001xxxxxxxxxxxxx
6268                                                  prfh.  */
6269                                               return 1783;
6270                                             }
6271                                           else
6272                                             {
6273                                               if (((word >> 31) & 0x1) == 0)
6274                                                 {
6275                                                   if (((word >> 10) & 0x1) == 0)
6276                                                     {
6277                                                       if (((word >> 12) & 0x1) == 0)
6278                                                         {
6279                                                           if (((word >> 22) & 0x1) == 0)
6280                                                             {
6281                                                               /* 33222222222211111111110000000000
6282                                                                  10987654321098765432109876543210
6283                                                                  010001x0101xxxxx0010x0xxxxxxxxxx
6284                                                                  sqdmlalb.  */
6285                                                               return 2168;
6286                                                             }
6287                                                           else
6288                                                             {
6289                                                               /* 33222222222211111111110000000000
6290                                                                  10987654321098765432109876543210
6291                                                                  010001x0111xxxxx0010x0xxxxxxxxxx
6292                                                                  sqdmlalb.  */
6293                                                               return 2169;
6294                                                             }
6295                                                         }
6296                                                       else
6297                                                         {
6298                                                           if (((word >> 22) & 0x1) == 0)
6299                                                             {
6300                                                               /* 33222222222211111111110000000000
6301                                                                  10987654321098765432109876543210
6302                                                                  010001x0101xxxxx0011x0xxxxxxxxxx
6303                                                                  sqdmlslb.  */
6304                                                               return 2175;
6305                                                             }
6306                                                           else
6307                                                             {
6308                                                               /* 33222222222211111111110000000000
6309                                                                  10987654321098765432109876543210
6310                                                                  010001x0111xxxxx0011x0xxxxxxxxxx
6311                                                                  sqdmlslb.  */
6312                                                               return 2176;
6313                                                             }
6314                                                         }
6315                                                     }
6316                                                   else
6317                                                     {
6318                                                       if (((word >> 12) & 0x1) == 0)
6319                                                         {
6320                                                           if (((word >> 22) & 0x1) == 0)
6321                                                             {
6322                                                               /* 33222222222211111111110000000000
6323                                                                  10987654321098765432109876543210
6324                                                                  010001x0101xxxxx0010x1xxxxxxxxxx
6325                                                                  sqdmlalt.  */
6326                                                               return 2172;
6327                                                             }
6328                                                           else
6329                                                             {
6330                                                               /* 33222222222211111111110000000000
6331                                                                  10987654321098765432109876543210
6332                                                                  010001x0111xxxxx0010x1xxxxxxxxxx
6333                                                                  sqdmlalt.  */
6334                                                               return 2173;
6335                                                             }
6336                                                         }
6337                                                       else
6338                                                         {
6339                                                           if (((word >> 22) & 0x1) == 0)
6340                                                             {
6341                                                               /* 33222222222211111111110000000000
6342                                                                  10987654321098765432109876543210
6343                                                                  010001x0101xxxxx0011x1xxxxxxxxxx
6344                                                                  sqdmlslt.  */
6345                                                               return 2179;
6346                                                             }
6347                                                           else
6348                                                             {
6349                                                               /* 33222222222211111111110000000000
6350                                                                  10987654321098765432109876543210
6351                                                                  010001x0111xxxxx0011x1xxxxxxxxxx
6352                                                                  sqdmlslt.  */
6353                                                               return 2180;
6354                                                             }
6355                                                         }
6356                                                     }
6357                                                 }
6358                                               else
6359                                                 {
6360                                                   /* 33222222222211111111110000000000
6361                                                      10987654321098765432109876543210
6362                                                      110001x01x1xxxxx001xxxxxxxxxxxxx
6363                                                      ldff1sh.  */
6364                                                   return 1680;
6365                                                 }
6366                                             }
6367                                         }
6368                                     }
6369                                 }
6370                               else
6371                                 {
6372                                   if (((word >> 30) & 0x1) == 0)
6373                                     {
6374                                       if (((word >> 31) & 0x1) == 0)
6375                                         {
6376                                           if (((word >> 21) & 0x1) == 0)
6377                                             {
6378                                               if (((word >> 16) & 0x1) == 0)
6379                                                 {
6380                                                   if (((word >> 17) & 0x1) == 0)
6381                                                     {
6382                                                       if (((word >> 18) & 0x1) == 0)
6383                                                         {
6384                                                           if (((word >> 19) & 0x1) == 0)
6385                                                             {
6386                                                               /* 33222222222211111111110000000000
6387                                                                  10987654321098765432109876543210
6388                                                                  000001x0xx0x0000101xxxxxxxxxxxxx
6389                                                                  sxtb.  */
6390                                                               return 1954;
6391                                                             }
6392                                                           else
6393                                                             {
6394                                                               /* 33222222222211111111110000000000
6395                                                                  10987654321098765432109876543210
6396                                                                  000001x0xx0x1000101xxxxxxxxxxxxx
6397                                                                  cls.  */
6398                                                               return 1319;
6399                                                             }
6400                                                         }
6401                                                       else
6402                                                         {
6403                                                           if (((word >> 19) & 0x1) == 0)
6404                                                             {
6405                                                               /* 33222222222211111111110000000000
6406                                                                  10987654321098765432109876543210
6407                                                                  000001x0xx0x0100101xxxxxxxxxxxxx
6408                                                                  sxtw.  */
6409                                                               return 1956;
6410                                                             }
6411                                                           else
6412                                                             {
6413                                                               /* 33222222222211111111110000000000
6414                                                                  10987654321098765432109876543210
6415                                                                  000001x0xx0x1100101xxxxxxxxxxxxx
6416                                                                  fabs.  */
6417                                                               return 1381;
6418                                                             }
6419                                                         }
6420                                                     }
6421                                                   else
6422                                                     {
6423                                                       if (((word >> 18) & 0x1) == 0)
6424                                                         {
6425                                                           if (((word >> 19) & 0x1) == 0)
6426                                                             {
6427                                                               /* 33222222222211111111110000000000
6428                                                                  10987654321098765432109876543210
6429                                                                  000001x0xx0x0010101xxxxxxxxxxxxx
6430                                                                  sxth.  */
6431                                                               return 1955;
6432                                                             }
6433                                                           else
6434                                                             {
6435                                                               /* 33222222222211111111110000000000
6436                                                                  10987654321098765432109876543210
6437                                                                  000001x0xx0x1010101xxxxxxxxxxxxx
6438                                                                  cnt.  */
6439                                                               return 1348;
6440                                                             }
6441                                                         }
6442                                                       else
6443                                                         {
6444                                                           if (((word >> 19) & 0x1) == 0)
6445                                                             {
6446                                                               /* 33222222222211111111110000000000
6447                                                                  10987654321098765432109876543210
6448                                                                  000001x0xx0x0110101xxxxxxxxxxxxx
6449                                                                  abs.  */
6450                                                               return 1277;
6451                                                             }
6452                                                           else
6453                                                             {
6454                                                               /* 33222222222211111111110000000000
6455                                                                  10987654321098765432109876543210
6456                                                                  000001x0xx0x1110101xxxxxxxxxxxxx
6457                                                                  not.  */
6458                                                               return 1755;
6459                                                             }
6460                                                         }
6461                                                     }
6462                                                 }
6463                                               else
6464                                                 {
6465                                                   if (((word >> 17) & 0x1) == 0)
6466                                                     {
6467                                                       if (((word >> 18) & 0x1) == 0)
6468                                                         {
6469                                                           if (((word >> 19) & 0x1) == 0)
6470                                                             {
6471                                                               /* 33222222222211111111110000000000
6472                                                                  10987654321098765432109876543210
6473                                                                  000001x0xx0x0001101xxxxxxxxxxxxx
6474                                                                  uxtb.  */
6475                                                               return 2017;
6476                                                             }
6477                                                           else
6478                                                             {
6479                                                               /* 33222222222211111111110000000000
6480                                                                  10987654321098765432109876543210
6481                                                                  000001x0xx0x1001101xxxxxxxxxxxxx
6482                                                                  clz.  */
6483                                                               return 1320;
6484                                                             }
6485                                                         }
6486                                                       else
6487                                                         {
6488                                                           if (((word >> 19) & 0x1) == 0)
6489                                                             {
6490                                                               /* 33222222222211111111110000000000
6491                                                                  10987654321098765432109876543210
6492                                                                  000001x0xx0x0101101xxxxxxxxxxxxx
6493                                                                  uxtw.  */
6494                                                               return 2019;
6495                                                             }
6496                                                           else
6497                                                             {
6498                                                               /* 33222222222211111111110000000000
6499                                                                  10987654321098765432109876543210
6500                                                                  000001x0xx0x1101101xxxxxxxxxxxxx
6501                                                                  fneg.  */
6502                                                               return 1458;
6503                                                             }
6504                                                         }
6505                                                     }
6506                                                   else
6507                                                     {
6508                                                       if (((word >> 18) & 0x1) == 0)
6509                                                         {
6510                                                           if (((word >> 19) & 0x1) == 0)
6511                                                             {
6512                                                               /* 33222222222211111111110000000000
6513                                                                  10987654321098765432109876543210
6514                                                                  000001x0xx0x0011101xxxxxxxxxxxxx
6515                                                                  uxth.  */
6516                                                               return 2018;
6517                                                             }
6518                                                           else
6519                                                             {
6520                                                               /* 33222222222211111111110000000000
6521                                                                  10987654321098765432109876543210
6522                                                                  000001x0xx0x1011101xxxxxxxxxxxxx
6523                                                                  cnot.  */
6524                                                               return 1347;
6525                                                             }
6526                                                         }
6527                                                       else
6528                                                         {
6529                                                           /* 33222222222211111111110000000000
6530                                                              10987654321098765432109876543210
6531                                                              000001x0xx0xx111101xxxxxxxxxxxxx
6532                                                              neg.  */
6533                                                           return 1752;
6534                                                         }
6535                                                     }
6536                                                 }
6537                                             }
6538                                           else
6539                                             {
6540                                               if (((word >> 12) & 0x1) == 0)
6541                                                 {
6542                                                   if (((word >> 23) & 0x1) == 0)
6543                                                     {
6544                                                       if (((word >> 22) & 0x1) == 0)
6545                                                         {
6546                                                           /* 33222222222211111111110000000000
6547                                                              10987654321098765432109876543210
6548                                                              000001x0001xxxxx1010xxxxxxxxxxxx
6549                                                              adr.  */
6550                                                           return 1283;
6551                                                         }
6552                                                       else
6553                                                         {
6554                                                           /* 33222222222211111111110000000000
6555                                                              10987654321098765432109876543210
6556                                                              000001x0011xxxxx1010xxxxxxxxxxxx
6557                                                              adr.  */
6558                                                           return 1284;
6559                                                         }
6560                                                     }
6561                                                   else
6562                                                     {
6563                                                       /* 33222222222211111111110000000000
6564                                                          10987654321098765432109876543210
6565                                                          000001x01x1xxxxx1010xxxxxxxxxxxx
6566                                                          adr.  */
6567                                                       return 1285;
6568                                                     }
6569                                                 }
6570                                               else
6571                                                 {
6572                                                   if (((word >> 10) & 0x1) == 0)
6573                                                     {
6574                                                       if (((word >> 11) & 0x1) == 0)
6575                                                         {
6576                                                           /* 33222222222211111111110000000000
6577                                                              10987654321098765432109876543210
6578                                                              000001x0xx1xxxxx101100xxxxxxxxxx
6579                                                              ftssel.  */
6580                                                           return 1484;
6581                                                         }
6582                                                       else
6583                                                         {
6584                                                           /* 33222222222211111111110000000000
6585                                                              10987654321098765432109876543210
6586                                                              000001x0xx1xxxxx101110xxxxxxxxxx
6587                                                              fexpa.  */
6588                                                           return 1428;
6589                                                         }
6590                                                     }
6591                                                   else
6592                                                     {
6593                                                       /* 33222222222211111111110000000000
6594                                                          10987654321098765432109876543210
6595                                                          000001x0xx1xxxxx1011x1xxxxxxxxxx
6596                                                          movprfx.  */
6597                                                       return 1745;
6598                                                     }
6599                                                 }
6600                                             }
6601                                         }
6602                                       else
6603                                         {
6604                                           if (((word >> 22) & 0x1) == 0)
6605                                             {
6606                                               if (((word >> 21) & 0x1) == 0)
6607                                                 {
6608                                                   if (((word >> 23) & 0x1) == 0)
6609                                                     {
6610                                                       /* 33222222222211111111110000000000
6611                                                          10987654321098765432109876543210
6612                                                          100001x0000xxxxx101xxxxxxxxxxxxx
6613                                                          ldnt1b.  */
6614                                                       return 2092;
6615                                                     }
6616                                                   else
6617                                                     {
6618                                                       /* 33222222222211111111110000000000
6619                                                          10987654321098765432109876543210
6620                                                          100001x0100xxxxx101xxxxxxxxxxxxx
6621                                                          ldnt1h.  */
6622                                                       return 2095;
6623                                                     }
6624                                                 }
6625                                               else
6626                                                 {
6627                                                   if (((word >> 23) & 0x1) == 0)
6628                                                     {
6629                                                       /* 33222222222211111111110000000000
6630                                                          10987654321098765432109876543210
6631                                                          100001x0001xxxxx101xxxxxxxxxxxxx
6632                                                          ldff1sb.  */
6633                                                       return 1671;
6634                                                     }
6635                                                   else
6636                                                     {
6637                                                       /* 33222222222211111111110000000000
6638                                                          10987654321098765432109876543210
6639                                                          100001x0101xxxxx101xxxxxxxxxxxxx
6640                                                          ldff1sh.  */
6641                                                       return 1683;
6642                                                     }
6643                                                 }
6644                                             }
6645                                           else
6646                                             {
6647                                               if (((word >> 23) & 0x1) == 0)
6648                                                 {
6649                                                   /* 33222222222211111111110000000000
6650                                                      10987654321098765432109876543210
6651                                                      100001x001xxxxxx101xxxxxxxxxxxxx
6652                                                      ld1rb.  */
6653                                                   return 1539;
6654                                                 }
6655                                               else
6656                                                 {
6657                                                   /* 33222222222211111111110000000000
6658                                                      10987654321098765432109876543210
6659                                                      100001x011xxxxxx101xxxxxxxxxxxxx
6660                                                      ld1rh.  */
6661                                                   return 1543;
6662                                                 }
6663                                             }
6664                                         }
6665                                     }
6666                                   else
6667                                     {
6668                                       if (((word >> 21) & 0x1) == 0)
6669                                         {
6670                                           if (((word >> 31) & 0x1) == 0)
6671                                             {
6672                                               if (((word >> 16) & 0x1) == 0)
6673                                                 {
6674                                                   if (((word >> 17) & 0x1) == 0)
6675                                                     {
6676                                                       if (((word >> 18) & 0x1) == 0)
6677                                                         {
6678                                                           if (((word >> 19) & 0x1) == 0)
6679                                                             {
6680                                                               /* 33222222222211111111110000000000
6681                                                                  10987654321098765432109876543210
6682                                                                  010001x0xx0x0000101xxxxxxxxxxxxx
6683                                                                  urecpe.  */
6684                                                               return 2303;
6685                                                             }
6686                                                           else
6687                                                             {
6688                                                               /* 33222222222211111111110000000000
6689                                                                  10987654321098765432109876543210
6690                                                                  010001x0xx0x1000101xxxxxxxxxxxxx
6691                                                                  sqabs.  */
6692                                                               return 2165;
6693                                                             }
6694                                                         }
6695                                                       else
6696                                                         {
6697                                                           if (((word >> 20) & 0x1) == 0)
6698                                                             {
6699                                                               /* 33222222222211111111110000000000
6700                                                                  10987654321098765432109876543210
6701                                                                  010001x0xx00x100101xxxxxxxxxxxxx
6702                                                                  sadalp.  */
6703                                                               return 2129;
6704                                                             }
6705                                                           else
6706                                                             {
6707                                                               /* 33222222222211111111110000000000
6708                                                                  10987654321098765432109876543210
6709                                                                  010001x0xx01x100101xxxxxxxxxxxxx
6710                                                                  smaxp.  */
6711                                                               return 2143;
6712                                                             }
6713                                                         }
6714                                                     }
6715                                                   else
6716                                                     {
6717                                                       /* 33222222222211111111110000000000
6718                                                          10987654321098765432109876543210
6719                                                          010001x0xx0xxx10101xxxxxxxxxxxxx
6720                                                          sminp.  */
6721                                                       return 2144;
6722                                                     }
6723                                                 }
6724                                               else
6725                                                 {
6726                                                   if (((word >> 17) & 0x1) == 0)
6727                                                     {
6728                                                       if (((word >> 18) & 0x1) == 0)
6729                                                         {
6730                                                           if (((word >> 19) & 0x1) == 0)
6731                                                             {
6732                                                               if (((word >> 20) & 0x1) == 0)
6733                                                                 {
6734                                                                   /* 33222222222211111111110000000000
6735                                                                      10987654321098765432109876543210
6736                                                                      010001x0xx000001101xxxxxxxxxxxxx
6737                                                                      ursqrte.  */
6738                                                                   return 2308;
6739                                                                 }
6740                                                               else
6741                                                                 {
6742                                                                   /* 33222222222211111111110000000000
6743                                                                      10987654321098765432109876543210
6744                                                                      010001x0xx010001101xxxxxxxxxxxxx
6745                                                                      addp.  */
6746                                                                   return 2054;
6747                                                                 }
6748                                                             }
6749                                                           else
6750                                                             {
6751                                                               /* 33222222222211111111110000000000
6752                                                                  10987654321098765432109876543210
6753                                                                  010001x0xx0x1001101xxxxxxxxxxxxx
6754                                                                  sqneg.  */
6755                                                               return 2192;
6756                                                             }
6757                                                         }
6758                                                       else
6759                                                         {
6760                                                           if (((word >> 20) & 0x1) == 0)
6761                                                             {
6762                                                               /* 33222222222211111111110000000000
6763                                                                  10987654321098765432109876543210
6764                                                                  010001x0xx00x101101xxxxxxxxxxxxx
6765                                                                  uadalp.  */
6766                                                               return 2260;
6767                                                             }
6768                                                           else
6769                                                             {
6770                                                               /* 33222222222211111111110000000000
6771                                                                  10987654321098765432109876543210
6772                                                                  010001x0xx01x101101xxxxxxxxxxxxx
6773                                                                  umaxp.  */
6774                                                               return 2268;
6775                                                             }
6776                                                         }
6777                                                     }
6778                                                   else
6779                                                     {
6780                                                       /* 33222222222211111111110000000000
6781                                                          10987654321098765432109876543210
6782                                                          010001x0xx0xxx11101xxxxxxxxxxxxx
6783                                                          uminp.  */
6784                                                       return 2269;
6785                                                     }
6786                                                 }
6787                                             }
6788                                           else
6789                                             {
6790                                               if (((word >> 23) & 0x1) == 0)
6791                                                 {
6792                                                   /* 33222222222211111111110000000000
6793                                                      10987654321098765432109876543210
6794                                                      110001x00x0xxxxx101xxxxxxxxxxxxx
6795                                                      ldff1sb.  */
6796                                                   return 1670;
6797                                                 }
6798                                               else
6799                                                 {
6800                                                   /* 33222222222211111111110000000000
6801                                                      10987654321098765432109876543210
6802                                                      110001x01x0xxxxx101xxxxxxxxxxxxx
6803                                                      ldff1sh.  */
6804                                                   return 1681;
6805                                                 }
6806                                             }
6807                                         }
6808                                       else
6809                                         {
6810                                           if (((word >> 22) & 0x1) == 0)
6811                                             {
6812                                               if (((word >> 23) & 0x1) == 0)
6813                                                 {
6814                                                   /* 33222222222211111111110000000000
6815                                                      10987654321098765432109876543210
6816                                                      x10001x0001xxxxx101xxxxxxxxxxxxx
6817                                                      ldff1sb.  */
6818                                                   return 1672;
6819                                                 }
6820                                               else
6821                                                 {
6822                                                   if (((word >> 31) & 0x1) == 0)
6823                                                     {
6824                                                       if (((word >> 10) & 0x1) == 0)
6825                                                         {
6826                                                           if (((word >> 12) & 0x1) == 0)
6827                                                             {
6828                                                               /* 33222222222211111111110000000000
6829                                                                  10987654321098765432109876543210
6830                                                                  010001x0101xxxxx1010x0xxxxxxxxxx
6831                                                                  smlslb.  */
6832                                                               return 2151;
6833                                                             }
6834                                                           else
6835                                                             {
6836                                                               /* 33222222222211111111110000000000
6837                                                                  10987654321098765432109876543210
6838                                                                  010001x0101xxxxx1011x0xxxxxxxxxx
6839                                                                  umlslb.  */
6840                                                               return 2276;
6841                                                             }
6842                                                         }
6843                                                       else
6844                                                         {
6845                                                           if (((word >> 12) & 0x1) == 0)
6846                                                             {
6847                                                               /* 33222222222211111111110000000000
6848                                                                  10987654321098765432109876543210
6849                                                                  010001x0101xxxxx1010x1xxxxxxxxxx
6850                                                                  smlslt.  */
6851                                                               return 2154;
6852                                                             }
6853                                                           else
6854                                                             {
6855                                                               /* 33222222222211111111110000000000
6856                                                                  10987654321098765432109876543210
6857                                                                  010001x0101xxxxx1011x1xxxxxxxxxx
6858                                                                  umlslt.  */
6859                                                               return 2279;
6860                                                             }
6861                                                         }
6862                                                     }
6863                                                   else
6864                                                     {
6865                                                       /* 33222222222211111111110000000000
6866                                                          10987654321098765432109876543210
6867                                                          110001x0101xxxxx101xxxxxxxxxxxxx
6868                                                          ldff1sh.  */
6869                                                       return 1684;
6870                                                     }
6871                                                 }
6872                                             }
6873                                           else
6874                                             {
6875                                               if (((word >> 23) & 0x1) == 0)
6876                                                 {
6877                                                   /* 33222222222211111111110000000000
6878                                                      10987654321098765432109876543210
6879                                                      x10001x0011xxxxx101xxxxxxxxxxxxx
6880                                                      prfh.  */
6881                                                   return 1784;
6882                                                 }
6883                                               else
6884                                                 {
6885                                                   if (((word >> 31) & 0x1) == 0)
6886                                                     {
6887                                                       if (((word >> 10) & 0x1) == 0)
6888                                                         {
6889                                                           if (((word >> 12) & 0x1) == 0)
6890                                                             {
6891                                                               /* 33222222222211111111110000000000
6892                                                                  10987654321098765432109876543210
6893                                                                  010001x0111xxxxx1010x0xxxxxxxxxx
6894                                                                  smlslb.  */
6895                                                               return 2152;
6896                                                             }
6897                                                           else
6898                                                             {
6899                                                               /* 33222222222211111111110000000000
6900                                                                  10987654321098765432109876543210
6901                                                                  010001x0111xxxxx1011x0xxxxxxxxxx
6902                                                                  umlslb.  */
6903                                                               return 2277;
6904                                                             }
6905                                                         }
6906                                                       else
6907                                                         {
6908                                                           if (((word >> 12) & 0x1) == 0)
6909                                                             {
6910                                                               /* 33222222222211111111110000000000
6911                                                                  10987654321098765432109876543210
6912                                                                  010001x0111xxxxx1010x1xxxxxxxxxx
6913                                                                  smlslt.  */
6914                                                               return 2155;
6915                                                             }
6916                                                           else
6917                                                             {
6918                                                               /* 33222222222211111111110000000000
6919                                                                  10987654321098765432109876543210
6920                                                                  010001x0111xxxxx1011x1xxxxxxxxxx
6921                                                                  umlslt.  */
6922                                                               return 2280;
6923                                                             }
6924                                                         }
6925                                                     }
6926                                                   else
6927                                                     {
6928                                                       /* 33222222222211111111110000000000
6929                                                          10987654321098765432109876543210
6930                                                          110001x0111xxxxx101xxxxxxxxxxxxx
6931                                                          ldff1sh.  */
6932                                                       return 1682;
6933                                                     }
6934                                                 }
6935                                             }
6936                                         }
6937                                     }
6938                                 }
6939                             }
6940                           else
6941                             {
6942                               if (((word >> 15) & 0x1) == 0)
6943                                 {
6944                                   if (((word >> 21) & 0x1) == 0)
6945                                     {
6946                                       if (((word >> 30) & 0x1) == 0)
6947                                         {
6948                                           if (((word >> 31) & 0x1) == 0)
6949                                             {
6950                                               /* 33222222222211111111110000000000
6951                                                  10987654321098765432109876543210
6952                                                  000001x0xx0xxxxx011xxxxxxxxxxxxx
6953                                                  mls.  */
6954                                               return 1744;
6955                                             }
6956                                           else
6957                                             {
6958                                               if (((word >> 23) & 0x1) == 0)
6959                                                 {
6960                                                   /* 33222222222211111111110000000000
6961                                                      10987654321098765432109876543210
6962                                                      100001x00x0xxxxx011xxxxxxxxxxxxx
6963                                                      ldff1b.  */
6964                                                   return 1628;
6965                                                 }
6966                                               else
6967                                                 {
6968                                                   /* 33222222222211111111110000000000
6969                                                      10987654321098765432109876543210
6970                                                      100001x01x0xxxxx011xxxxxxxxxxxxx
6971                                                      ldff1h.  */
6972                                                   return 1648;
6973                                                 }
6974                                             }
6975                                         }
6976                                       else
6977                                         {
6978                                           if (((word >> 31) & 0x1) == 0)
6979                                             {
6980                                               if (((word >> 10) & 0x1) == 0)
6981                                                 {
6982                                                   if (((word >> 11) & 0x1) == 0)
6983                                                     {
6984                                                       if (((word >> 12) & 0x1) == 0)
6985                                                         {
6986                                                           /* 33222222222211111111110000000000
6987                                                              10987654321098765432109876543210
6988                                                              010001x0xx0xxxxx011000xxxxxxxxxx
6989                                                              sqdmlalb.  */
6990                                                           return 2170;
6991                                                         }
6992                                                       else
6993                                                         {
6994                                                           /* 33222222222211111111110000000000
6995                                                              10987654321098765432109876543210
6996                                                              010001x0xx0xxxxx011100xxxxxxxxxx
6997                                                              sqrdmlah.  */
6998                                                           return 2199;
6999                                                         }
7000                                                     }
7001                                                   else
7002                                                     {
7003                                                       if (((word >> 12) & 0x1) == 0)
7004                                                         {
7005                                                           /* 33222222222211111111110000000000
7006                                                              10987654321098765432109876543210
7007                                                              010001x0xx0xxxxx011010xxxxxxxxxx
7008                                                              sqdmlslb.  */
7009                                                           return 2177;
7010                                                         }
7011                                                       else
7012                                                         {
7013                                                           /* 33222222222211111111110000000000
7014                                                              10987654321098765432109876543210
7015                                                              010001x0xx0xxxxx011110xxxxxxxxxx
7016                                                              usdot.  */
7017                                                           return 2397;
7018                                                         }
7019                                                     }
7020                                                 }
7021                                               else
7022                                                 {
7023                                                   if (((word >> 11) & 0x1) == 0)
7024                                                     {
7025                                                       if (((word >> 12) & 0x1) == 0)
7026                                                         {
7027                                                           /* 33222222222211111111110000000000
7028                                                              10987654321098765432109876543210
7029                                                              010001x0xx0xxxxx011001xxxxxxxxxx
7030                                                              sqdmlalt.  */
7031                                                           return 2174;
7032                                                         }
7033                                                       else
7034                                                         {
7035                                                           /* 33222222222211111111110000000000
7036                                                              10987654321098765432109876543210
7037                                                              010001x0xx0xxxxx011101xxxxxxxxxx
7038                                                              sqrdmlsh.  */
7039                                                           return 2203;
7040                                                         }
7041                                                     }
7042                                                   else
7043                                                     {
7044                                                       /* 33222222222211111111110000000000
7045                                                          10987654321098765432109876543210
7046                                                          010001x0xx0xxxxx011x11xxxxxxxxxx
7047                                                          sqdmlslt.  */
7048                                                       return 2181;
7049                                                     }
7050                                                 }
7051                                             }
7052                                           else
7053                                             {
7054                                               if (((word >> 23) & 0x1) == 0)
7055                                                 {
7056                                                   /* 33222222222211111111110000000000
7057                                                      10987654321098765432109876543210
7058                                                      110001x00x0xxxxx011xxxxxxxxxxxxx
7059                                                      ldff1b.  */
7060                                                   return 1637;
7061                                                 }
7062                                               else
7063                                                 {
7064                                                   /* 33222222222211111111110000000000
7065                                                      10987654321098765432109876543210
7066                                                      110001x01x0xxxxx011xxxxxxxxxxxxx
7067                                                      ldff1h.  */
7068                                                   return 1656;
7069                                                 }
7070                                             }
7071                                         }
7072                                     }
7073                                   else
7074                                     {
7075                                       if (((word >> 30) & 0x1) == 0)
7076                                         {
7077                                           if (((word >> 31) & 0x1) == 0)
7078                                             {
7079                                               if (((word >> 10) & 0x1) == 0)
7080                                                 {
7081                                                   if (((word >> 11) & 0x1) == 0)
7082                                                     {
7083                                                       if (((word >> 12) & 0x1) == 0)
7084                                                         {
7085                                                           /* 33222222222211111111110000000000
7086                                                              10987654321098765432109876543210
7087                                                              000001x0xx1xxxxx011000xxxxxxxxxx
7088                                                              mul.  */
7089                                                           return 2112;
7090                                                         }
7091                                                       else
7092                                                         {
7093                                                           /* 33222222222211111111110000000000
7094                                                              10987654321098765432109876543210
7095                                                              000001x0xx1xxxxx011100xxxxxxxxxx
7096                                                              sqdmulh.  */
7097                                                           return 2185;
7098                                                         }
7099                                                     }
7100                                                   else
7101                                                     {
7102                                                       /* 33222222222211111111110000000000
7103                                                          10987654321098765432109876543210
7104                                                          000001x0xx1xxxxx011x10xxxxxxxxxx
7105                                                          smulh.  */
7106                                                       return 2157;
7107                                                     }
7108                                                 }
7109                                               else
7110                                                 {
7111                                                   if (((word >> 11) & 0x1) == 0)
7112                                                     {
7113                                                       if (((word >> 12) & 0x1) == 0)
7114                                                         {
7115                                                           /* 33222222222211111111110000000000
7116                                                              10987654321098765432109876543210
7117                                                              000001x0xx1xxxxx011001xxxxxxxxxx
7118                                                              pmul.  */
7119                                                           return 2115;
7120                                                         }
7121                                                       else
7122                                                         {
7123                                                           /* 33222222222211111111110000000000
7124                                                              10987654321098765432109876543210
7125                                                              000001x0xx1xxxxx011101xxxxxxxxxx
7126                                                              sqrdmulh.  */
7127                                                           return 2207;
7128                                                         }
7129                                                     }
7130                                                   else
7131                                                     {
7132                                                       /* 33222222222211111111110000000000
7133                                                          10987654321098765432109876543210
7134                                                          000001x0xx1xxxxx011x11xxxxxxxxxx
7135                                                          umulh.  */
7136                                                       return 2282;
7137                                                     }
7138                                                 }
7139                                             }
7140                                           else
7141                                             {
7142                                               if (((word >> 23) & 0x1) == 0)
7143                                                 {
7144                                                   /* 33222222222211111111110000000000
7145                                                      10987654321098765432109876543210
7146                                                      100001x00x1xxxxx011xxxxxxxxxxxxx
7147                                                      prfd.  */
7148                                                   return 1774;
7149                                                 }
7150                                               else
7151                                                 {
7152                                                   /* 33222222222211111111110000000000
7153                                                      10987654321098765432109876543210
7154                                                      100001x01x1xxxxx011xxxxxxxxxxxxx
7155                                                      ldff1h.  */
7156                                                   return 1649;
7157                                                 }
7158                                             }
7159                                         }
7160                                       else
7161                                         {
7162                                           if (((word >> 23) & 0x1) == 0)
7163                                             {
7164                                               /* 33222222222211111111110000000000
7165                                                  10987654321098765432109876543210
7166                                                  x10001x00x1xxxxx011xxxxxxxxxxxxx
7167                                                  prfd.  */
7168                                               return 1776;
7169                                             }
7170                                           else
7171                                             {
7172                                               if (((word >> 31) & 0x1) == 0)
7173                                                 {
7174                                                   if (((word >> 12) & 0x1) == 0)
7175                                                     {
7176                                                       if (((word >> 22) & 0x1) == 0)
7177                                                         {
7178                                                           /* 33222222222211111111110000000000
7179                                                              10987654321098765432109876543210
7180                                                              010001x0101xxxxx0110xxxxxxxxxxxx
7181                                                              cmla.  */
7182                                                           return 2064;
7183                                                         }
7184                                                       else
7185                                                         {
7186                                                           /* 33222222222211111111110000000000
7187                                                              10987654321098765432109876543210
7188                                                              010001x0111xxxxx0110xxxxxxxxxxxx
7189                                                              cmla.  */
7190                                                           return 2065;
7191                                                         }
7192                                                     }
7193                                                   else
7194                                                     {
7195                                                       if (((word >> 22) & 0x1) == 0)
7196                                                         {
7197                                                           /* 33222222222211111111110000000000
7198                                                              10987654321098765432109876543210
7199                                                              010001x0101xxxxx0111xxxxxxxxxxxx
7200                                                              sqrdcmlah.  */
7201                                                           return 2193;
7202                                                         }
7203                                                       else
7204                                                         {
7205                                                           /* 33222222222211111111110000000000
7206                                                              10987654321098765432109876543210
7207                                                              010001x0111xxxxx0111xxxxxxxxxxxx
7208                                                              sqrdcmlah.  */
7209                                                           return 2194;
7210                                                         }
7211                                                     }
7212                                                 }
7213                                               else
7214                                                 {
7215                                                   /* 33222222222211111111110000000000
7216                                                      10987654321098765432109876543210
7217                                                      110001x01x1xxxxx011xxxxxxxxxxxxx
7218                                                      ldff1h.  */
7219                                                   return 1657;
7220                                                 }
7221                                             }
7222                                         }
7223                                     }
7224                                 }
7225                               else
7226                                 {
7227                                   if (((word >> 30) & 0x1) == 0)
7228                                     {
7229                                       if (((word >> 31) & 0x1) == 0)
7230                                         {
7231                                           if (((word >> 21) & 0x1) == 0)
7232                                             {
7233                                               /* 33222222222211111111110000000000
7234                                                  10987654321098765432109876543210
7235                                                  000001x0xx0xxxxx111xxxxxxxxxxxxx
7236                                                  msb.  */
7237                                               return 1747;
7238                                             }
7239                                           else
7240                                             {
7241                                               if (((word >> 10) & 0x1) == 0)
7242                                                 {
7243                                                   if (((word >> 11) & 0x1) == 0)
7244                                                     {
7245                                                       if (((word >> 12) & 0x1) == 0)
7246                                                         {
7247                                                           if (((word >> 20) & 0x1) == 0)
7248                                                             {
7249                                                               if (((word >> 22) & 0x1) == 0)
7250                                                                 {
7251                                                                   if (((word >> 23) & 0x1) == 0)
7252                                                                     {
7253                                                                       /* 33222222222211111111110000000000
7254                                                                          10987654321098765432109876543210
7255                                                                          000001x00010xxxx111000xxxxxxxxxx
7256                                                                          cntb.  */
7257                                                                       return 1349;
7258                                                                     }
7259                                                                   else
7260                                                                     {
7261                                                                       /* 33222222222211111111110000000000
7262                                                                          10987654321098765432109876543210
7263                                                                          000001x01010xxxx111000xxxxxxxxxx
7264                                                                          cntw.  */
7265                                                                       return 1353;
7266                                                                     }
7267                                                                 }
7268                                                               else
7269                                                                 {
7270                                                                   if (((word >> 23) & 0x1) == 0)
7271                                                                     {
7272                                                                       /* 33222222222211111111110000000000
7273                                                                          10987654321098765432109876543210
7274                                                                          000001x00110xxxx111000xxxxxxxxxx
7275                                                                          cnth.  */
7276                                                                       return 1351;
7277                                                                     }
7278                                                                   else
7279                                                                     {
7280                                                                       /* 33222222222211111111110000000000
7281                                                                          10987654321098765432109876543210
7282                                                                          000001x01110xxxx111000xxxxxxxxxx
7283                                                                          cntd.  */
7284                                                                       return 1350;
7285                                                                     }
7286                                                                 }
7287                                                             }
7288                                                           else
7289                                                             {
7290                                                               if (((word >> 22) & 0x1) == 0)
7291                                                                 {
7292                                                                   if (((word >> 23) & 0x1) == 0)
7293                                                                     {
7294                                                                       /* 33222222222211111111110000000000
7295                                                                          10987654321098765432109876543210
7296                                                                          000001x00011xxxx111000xxxxxxxxxx
7297                                                                          incb.  */
7298                                                                       return 1485;
7299                                                                     }
7300                                                                   else
7301                                                                     {
7302                                                                       /* 33222222222211111111110000000000
7303                                                                          10987654321098765432109876543210
7304                                                                          000001x01011xxxx111000xxxxxxxxxx
7305                                                                          incw.  */
7306                                                                       return 1493;
7307                                                                     }
7308                                                                 }
7309                                                               else
7310                                                                 {
7311                                                                   if (((word >> 23) & 0x1) == 0)
7312                                                                     {
7313                                                                       /* 33222222222211111111110000000000
7314                                                                          10987654321098765432109876543210
7315                                                                          000001x00111xxxx111000xxxxxxxxxx
7316                                                                          inch.  */
7317                                                                       return 1489;
7318                                                                     }
7319                                                                   else
7320                                                                     {
7321                                                                       /* 33222222222211111111110000000000
7322                                                                          10987654321098765432109876543210
7323                                                                          000001x01111xxxx111000xxxxxxxxxx
7324                                                                          incd.  */
7325                                                                       return 1487;
7326                                                                     }
7327                                                                 }
7328                                                             }
7329                                                         }
7330                                                       else
7331                                                         {
7332                                                           if (((word >> 20) & 0x1) == 0)
7333                                                             {
7334                                                               if (((word >> 22) & 0x1) == 0)
7335                                                                 {
7336                                                                   if (((word >> 23) & 0x1) == 0)
7337                                                                     {
7338                                                                       /* 33222222222211111111110000000000
7339                                                                          10987654321098765432109876543210
7340                                                                          000001x00010xxxx111100xxxxxxxxxx
7341                                                                          sqincb.  */
7342                                                                       return 1852;
7343                                                                     }
7344                                                                   else
7345                                                                     {
7346                                                                       /* 33222222222211111111110000000000
7347                                                                          10987654321098765432109876543210
7348                                                                          000001x01010xxxx111100xxxxxxxxxx
7349                                                                          sqincw.  */
7350                                                                       return 1864;
7351                                                                     }
7352                                                                 }
7353                                                               else
7354                                                                 {
7355                                                                   if (((word >> 23) & 0x1) == 0)
7356                                                                     {
7357                                                                       /* 33222222222211111111110000000000
7358                                                                          10987654321098765432109876543210
7359                                                                          000001x00110xxxx111100xxxxxxxxxx
7360                                                                          sqinch.  */
7361                                                                       return 1858;
7362                                                                     }
7363                                                                   else
7364                                                                     {
7365                                                                       /* 33222222222211111111110000000000
7366                                                                          10987654321098765432109876543210
7367                                                                          000001x01110xxxx111100xxxxxxxxxx
7368                                                                          sqincd.  */
7369                                                                       return 1855;
7370                                                                     }
7371                                                                 }
7372                                                             }
7373                                                           else
7374                                                             {
7375                                                               if (((word >> 22) & 0x1) == 0)
7376                                                                 {
7377                                                                   if (((word >> 23) & 0x1) == 0)
7378                                                                     {
7379                                                                       /* 33222222222211111111110000000000
7380                                                                          10987654321098765432109876543210
7381                                                                          000001x00011xxxx111100xxxxxxxxxx
7382                                                                          sqincb.  */
7383                                                                       return 1851;
7384                                                                     }
7385                                                                   else
7386                                                                     {
7387                                                                       /* 33222222222211111111110000000000
7388                                                                          10987654321098765432109876543210
7389                                                                          000001x01011xxxx111100xxxxxxxxxx
7390                                                                          sqincw.  */
7391                                                                       return 1863;
7392                                                                     }
7393                                                                 }
7394                                                               else
7395                                                                 {
7396                                                                   if (((word >> 23) & 0x1) == 0)
7397                                                                     {
7398                                                                       /* 33222222222211111111110000000000
7399                                                                          10987654321098765432109876543210
7400                                                                          000001x00111xxxx111100xxxxxxxxxx
7401                                                                          sqinch.  */
7402                                                                       return 1857;
7403                                                                     }
7404                                                                   else
7405                                                                     {
7406                                                                       /* 33222222222211111111110000000000
7407                                                                          10987654321098765432109876543210
7408                                                                          000001x01111xxxx111100xxxxxxxxxx
7409                                                                          sqincd.  */
7410                                                                       return 1854;
7411                                                                     }
7412                                                                 }
7413                                                             }
7414                                                         }
7415                                                     }
7416                                                   else
7417                                                     {
7418                                                       if (((word >> 20) & 0x1) == 0)
7419                                                         {
7420                                                           if (((word >> 22) & 0x1) == 0)
7421                                                             {
7422                                                               if (((word >> 23) & 0x1) == 0)
7423                                                                 {
7424                                                                   /* 33222222222211111111110000000000
7425                                                                      10987654321098765432109876543210
7426                                                                      000001x00010xxxx111x10xxxxxxxxxx
7427                                                                      sqdecb.  */
7428                                                                   return 1838;
7429                                                                 }
7430                                                               else
7431                                                                 {
7432                                                                   /* 33222222222211111111110000000000
7433                                                                      10987654321098765432109876543210
7434                                                                      000001x01010xxxx111x10xxxxxxxxxx
7435                                                                      sqdecw.  */
7436                                                                   return 1850;
7437                                                                 }
7438                                                             }
7439                                                           else
7440                                                             {
7441                                                               if (((word >> 23) & 0x1) == 0)
7442                                                                 {
7443                                                                   /* 33222222222211111111110000000000
7444                                                                      10987654321098765432109876543210
7445                                                                      000001x00110xxxx111x10xxxxxxxxxx
7446                                                                      sqdech.  */
7447                                                                   return 1844;
7448                                                                 }
7449                                                               else
7450                                                                 {
7451                                                                   /* 33222222222211111111110000000000
7452                                                                      10987654321098765432109876543210
7453                                                                      000001x01110xxxx111x10xxxxxxxxxx
7454                                                                      sqdecd.  */
7455                                                                   return 1841;
7456                                                                 }
7457                                                             }
7458                                                         }
7459                                                       else
7460                                                         {
7461                                                           if (((word >> 22) & 0x1) == 0)
7462                                                             {
7463                                                               if (((word >> 23) & 0x1) == 0)
7464                                                                 {
7465                                                                   /* 33222222222211111111110000000000
7466                                                                      10987654321098765432109876543210
7467                                                                      000001x00011xxxx111x10xxxxxxxxxx
7468                                                                      sqdecb.  */
7469                                                                   return 1837;
7470                                                                 }
7471                                                               else
7472                                                                 {
7473                                                                   /* 33222222222211111111110000000000
7474                                                                      10987654321098765432109876543210
7475                                                                      000001x01011xxxx111x10xxxxxxxxxx
7476                                                                      sqdecw.  */
7477                                                                   return 1849;
7478                                                                 }
7479                                                             }
7480                                                           else
7481                                                             {
7482                                                               if (((word >> 23) & 0x1) == 0)
7483                                                                 {
7484                                                                   /* 33222222222211111111110000000000
7485                                                                      10987654321098765432109876543210
7486                                                                      000001x00111xxxx111x10xxxxxxxxxx
7487                                                                      sqdech.  */
7488                                                                   return 1843;
7489                                                                 }
7490                                                               else
7491                                                                 {
7492                                                                   /* 33222222222211111111110000000000
7493                                                                      10987654321098765432109876543210
7494                                                                      000001x01111xxxx111x10xxxxxxxxxx
7495                                                                      sqdecd.  */
7496                                                                   return 1840;
7497                                                                 }
7498                                                             }
7499                                                         }
7500                                                     }
7501                                                 }
7502                                               else
7503                                                 {
7504                                                   if (((word >> 11) & 0x1) == 0)
7505                                                     {
7506                                                       if (((word >> 12) & 0x1) == 0)
7507                                                         {
7508                                                           if (((word >> 22) & 0x1) == 0)
7509                                                             {
7510                                                               if (((word >> 23) & 0x1) == 0)
7511                                                                 {
7512                                                                   /* 33222222222211111111110000000000
7513                                                                      10987654321098765432109876543210
7514                                                                      000001x0001xxxxx111001xxxxxxxxxx
7515                                                                      decb.  */
7516                                                                   return 1360;
7517                                                                 }
7518                                                               else
7519                                                                 {
7520                                                                   /* 33222222222211111111110000000000
7521                                                                      10987654321098765432109876543210
7522                                                                      000001x0101xxxxx111001xxxxxxxxxx
7523                                                                      decw.  */
7524                                                                   return 1368;
7525                                                                 }
7526                                                             }
7527                                                           else
7528                                                             {
7529                                                               if (((word >> 23) & 0x1) == 0)
7530                                                                 {
7531                                                                   /* 33222222222211111111110000000000
7532                                                                      10987654321098765432109876543210
7533                                                                      000001x0011xxxxx111001xxxxxxxxxx
7534                                                                      dech.  */
7535                                                                   return 1364;
7536                                                                 }
7537                                                               else
7538                                                                 {
7539                                                                   /* 33222222222211111111110000000000
7540                                                                      10987654321098765432109876543210
7541                                                                      000001x0111xxxxx111001xxxxxxxxxx
7542                                                                      decd.  */
7543                                                                   return 1362;
7544                                                                 }
7545                                                             }
7546                                                         }
7547                                                       else
7548                                                         {
7549                                                           if (((word >> 20) & 0x1) == 0)
7550                                                             {
7551                                                               if (((word >> 22) & 0x1) == 0)
7552                                                                 {
7553                                                                   if (((word >> 23) & 0x1) == 0)
7554                                                                     {
7555                                                                       /* 33222222222211111111110000000000
7556                                                                          10987654321098765432109876543210
7557                                                                          000001x00010xxxx111101xxxxxxxxxx
7558                                                                          uqincb.  */
7559                                                                       return 1999;
7560                                                                     }
7561                                                                   else
7562                                                                     {
7563                                                                       /* 33222222222211111111110000000000
7564                                                                          10987654321098765432109876543210
7565                                                                          000001x01010xxxx111101xxxxxxxxxx
7566                                                                          uqincw.  */
7567                                                                       return 2011;
7568                                                                     }
7569                                                                 }
7570                                                               else
7571                                                                 {
7572                                                                   if (((word >> 23) & 0x1) == 0)
7573                                                                     {
7574                                                                       /* 33222222222211111111110000000000
7575                                                                          10987654321098765432109876543210
7576                                                                          000001x00110xxxx111101xxxxxxxxxx
7577                                                                          uqinch.  */
7578                                                                       return 2005;
7579                                                                     }
7580                                                                   else
7581                                                                     {
7582                                                                       /* 33222222222211111111110000000000
7583                                                                          10987654321098765432109876543210
7584                                                                          000001x01110xxxx111101xxxxxxxxxx
7585                                                                          uqincd.  */
7586                                                                       return 2002;
7587                                                                     }
7588                                                                 }
7589                                                             }
7590                                                           else
7591                                                             {
7592                                                               if (((word >> 22) & 0x1) == 0)
7593                                                                 {
7594                                                                   if (((word >> 23) & 0x1) == 0)
7595                                                                     {
7596                                                                       /* 33222222222211111111110000000000
7597                                                                          10987654321098765432109876543210
7598                                                                          000001x00011xxxx111101xxxxxxxxxx
7599                                                                          uqincb.  */
7600                                                                       return 2000;
7601                                                                     }
7602                                                                   else
7603                                                                     {
7604                                                                       /* 33222222222211111111110000000000
7605                                                                          10987654321098765432109876543210
7606                                                                          000001x01011xxxx111101xxxxxxxxxx
7607                                                                          uqincw.  */
7608                                                                       return 2012;
7609                                                                     }
7610                                                                 }
7611                                                               else
7612                                                                 {
7613                                                                   if (((word >> 23) & 0x1) == 0)
7614                                                                     {
7615                                                                       /* 33222222222211111111110000000000
7616                                                                          10987654321098765432109876543210
7617                                                                          000001x00111xxxx111101xxxxxxxxxx
7618                                                                          uqinch.  */
7619                                                                       return 2006;
7620                                                                     }
7621                                                                   else
7622                                                                     {
7623                                                                       /* 33222222222211111111110000000000
7624                                                                          10987654321098765432109876543210
7625                                                                          000001x01111xxxx111101xxxxxxxxxx
7626                                                                          uqincd.  */
7627                                                                       return 2003;
7628                                                                     }
7629                                                                 }
7630                                                             }
7631                                                         }
7632                                                     }
7633                                                   else
7634                                                     {
7635                                                       if (((word >> 20) & 0x1) == 0)
7636                                                         {
7637                                                           if (((word >> 22) & 0x1) == 0)
7638                                                             {
7639                                                               if (((word >> 23) & 0x1) == 0)
7640                                                                 {
7641                                                                   /* 33222222222211111111110000000000
7642                                                                      10987654321098765432109876543210
7643                                                                      000001x00010xxxx111x11xxxxxxxxxx
7644                                                                      uqdecb.  */
7645                                                                   return 1985;
7646                                                                 }
7647                                                               else
7648                                                                 {
7649                                                                   /* 33222222222211111111110000000000
7650                                                                      10987654321098765432109876543210
7651                                                                      000001x01010xxxx111x11xxxxxxxxxx
7652                                                                      uqdecw.  */
7653                                                                   return 1997;
7654                                                                 }
7655                                                             }
7656                                                           else
7657                                                             {
7658                                                               if (((word >> 23) & 0x1) == 0)
7659                                                                 {
7660                                                                   /* 33222222222211111111110000000000
7661                                                                      10987654321098765432109876543210
7662                                                                      000001x00110xxxx111x11xxxxxxxxxx
7663                                                                      uqdech.  */
7664                                                                   return 1991;
7665                                                                 }
7666                                                               else
7667                                                                 {
7668                                                                   /* 33222222222211111111110000000000
7669                                                                      10987654321098765432109876543210
7670                                                                      000001x01110xxxx111x11xxxxxxxxxx
7671                                                                      uqdecd.  */
7672                                                                   return 1988;
7673                                                                 }
7674                                                             }
7675                                                         }
7676                                                       else
7677                                                         {
7678                                                           if (((word >> 22) & 0x1) == 0)
7679                                                             {
7680                                                               if (((word >> 23) & 0x1) == 0)
7681                                                                 {
7682                                                                   /* 33222222222211111111110000000000
7683                                                                      10987654321098765432109876543210
7684                                                                      000001x00011xxxx111x11xxxxxxxxxx
7685                                                                      uqdecb.  */
7686                                                                   return 1986;
7687                                                                 }
7688                                                               else
7689                                                                 {
7690                                                                   /* 33222222222211111111110000000000
7691                                                                      10987654321098765432109876543210
7692                                                                      000001x01011xxxx111x11xxxxxxxxxx
7693                                                                      uqdecw.  */
7694                                                                   return 1998;
7695                                                                 }
7696                                                             }
7697                                                           else
7698                                                             {
7699                                                               if (((word >> 23) & 0x1) == 0)
7700                                                                 {
7701                                                                   /* 33222222222211111111110000000000
7702                                                                      10987654321098765432109876543210
7703                                                                      000001x00111xxxx111x11xxxxxxxxxx
7704                                                                      uqdech.  */
7705                                                                   return 1992;
7706                                                                 }
7707                                                               else
7708                                                                 {
7709                                                                   /* 33222222222211111111110000000000
7710                                                                      10987654321098765432109876543210
7711                                                                      000001x01111xxxx111x11xxxxxxxxxx
7712                                                                      uqdecd.  */
7713                                                                   return 1989;
7714                                                                 }
7715                                                             }
7716                                                         }
7717                                                     }
7718                                                 }
7719                                             }
7720                                         }
7721                                       else
7722                                         {
7723                                           if (((word >> 22) & 0x1) == 0)
7724                                             {
7725                                               if (((word >> 21) & 0x1) == 0)
7726                                                 {
7727                                                   if (((word >> 23) & 0x1) == 0)
7728                                                     {
7729                                                       /* 33222222222211111111110000000000
7730                                                          10987654321098765432109876543210
7731                                                          100001x0000xxxxx111xxxxxxxxxxxxx
7732                                                          prfb.  */
7733                                                       return 1771;
7734                                                     }
7735                                                   else
7736                                                     {
7737                                                       /* 33222222222211111111110000000000
7738                                                          10987654321098765432109876543210
7739                                                          100001x0100xxxxx111xxxxxxxxxxxxx
7740                                                          prfh.  */
7741                                                       return 1785;
7742                                                     }
7743                                                 }
7744                                               else
7745                                                 {
7746                                                   if (((word >> 23) & 0x1) == 0)
7747                                                     {
7748                                                       /* 33222222222211111111110000000000
7749                                                          10987654321098765432109876543210
7750                                                          100001x0001xxxxx111xxxxxxxxxxxxx
7751                                                          ldff1b.  */
7752                                                       return 1639;
7753                                                     }
7754                                                   else
7755                                                     {
7756                                                       /* 33222222222211111111110000000000
7757                                                          10987654321098765432109876543210
7758                                                          100001x0101xxxxx111xxxxxxxxxxxxx
7759                                                          ldff1h.  */
7760                                                       return 1660;
7761                                                     }
7762                                                 }
7763                                             }
7764                                           else
7765                                             {
7766                                               if (((word >> 23) & 0x1) == 0)
7767                                                 {
7768                                                   /* 33222222222211111111110000000000
7769                                                      10987654321098765432109876543210
7770                                                      100001x001xxxxxx111xxxxxxxxxxxxx
7771                                                      ld1rb.  */
7772                                                   return 1541;
7773                                                 }
7774                                               else
7775                                                 {
7776                                                   /* 33222222222211111111110000000000
7777                                                      10987654321098765432109876543210
7778                                                      100001x011xxxxxx111xxxxxxxxxxxxx
7779                                                      ld1rh.  */
7780                                                   return 1545;
7781                                                 }
7782                                             }
7783                                         }
7784                                     }
7785                                   else
7786                                     {
7787                                       if (((word >> 21) & 0x1) == 0)
7788                                         {
7789                                           if (((word >> 22) & 0x1) == 0)
7790                                             {
7791                                               if (((word >> 23) & 0x1) == 0)
7792                                                 {
7793                                                   /* 33222222222211111111110000000000
7794                                                      10987654321098765432109876543210
7795                                                      x10001x0000xxxxx111xxxxxxxxxxxxx
7796                                                      prfb.  */
7797                                                   return 1773;
7798                                                 }
7799                                               else
7800                                                 {
7801                                                   /* 33222222222211111111110000000000
7802                                                      10987654321098765432109876543210
7803                                                      x10001x0100xxxxx111xxxxxxxxxxxxx
7804                                                      prfh.  */
7805                                                   return 1787;
7806                                                 }
7807                                             }
7808                                           else
7809                                             {
7810                                               if (((word >> 23) & 0x1) == 0)
7811                                                 {
7812                                                   /* 33222222222211111111110000000000
7813                                                      10987654321098765432109876543210
7814                                                      x10001x0010xxxxx111xxxxxxxxxxxxx
7815                                                      ldff1b.  */
7816                                                   return 1638;
7817                                                 }
7818                                               else
7819                                                 {
7820                                                   /* 33222222222211111111110000000000
7821                                                      10987654321098765432109876543210
7822                                                      x10001x0110xxxxx111xxxxxxxxxxxxx
7823                                                      ldff1h.  */
7824                                                   return 1658;
7825                                                 }
7826                                             }
7827                                         }
7828                                       else
7829                                         {
7830                                           if (((word >> 23) & 0x1) == 0)
7831                                             {
7832                                               if (((word >> 31) & 0x1) == 0)
7833                                                 {
7834                                                   if (((word >> 10) & 0x1) == 0)
7835                                                     {
7836                                                       if (((word >> 11) & 0x1) == 0)
7837                                                         {
7838                                                           /* 33222222222211111111110000000000
7839                                                              10987654321098765432109876543210
7840                                                              010001x00x1xxxxx111x00xxxxxxxxxx
7841                                                              sqdmulh.  */
7842                                                           return 2182;
7843                                                         }
7844                                                       else
7845                                                         {
7846                                                           /* 33222222222211111111110000000000
7847                                                              10987654321098765432109876543210
7848                                                              010001x00x1xxxxx111x10xxxxxxxxxx
7849                                                              mul.  */
7850                                                           return 2109;
7851                                                         }
7852                                                     }
7853                                                   else
7854                                                     {
7855                                                       /* 33222222222211111111110000000000
7856                                                          10987654321098765432109876543210
7857                                                          010001x00x1xxxxx111xx1xxxxxxxxxx
7858                                                          sqrdmulh.  */
7859                                                       return 2204;
7860                                                     }
7861                                                 }
7862                                               else
7863                                                 {
7864                                                   if (((word >> 22) & 0x1) == 0)
7865                                                     {
7866                                                       /* 33222222222211111111110000000000
7867                                                          10987654321098765432109876543210
7868                                                          110001x0001xxxxx111xxxxxxxxxxxxx
7869                                                          ldff1b.  */
7870                                                       return 1640;
7871                                                     }
7872                                                   else
7873                                                     {
7874                                                       /* 33222222222211111111110000000000
7875                                                          10987654321098765432109876543210
7876                                                          110001x0011xxxxx111xxxxxxxxxxxxx
7877                                                          prfd.  */
7878                                                       return 1777;
7879                                                     }
7880                                                 }
7881                                             }
7882                                           else
7883                                             {
7884                                               if (((word >> 22) & 0x1) == 0)
7885                                                 {
7886                                                   if (((word >> 31) & 0x1) == 0)
7887                                                     {
7888                                                       if (((word >> 10) & 0x1) == 0)
7889                                                         {
7890                                                           if (((word >> 12) & 0x1) == 0)
7891                                                             {
7892                                                               /* 33222222222211111111110000000000
7893                                                                  10987654321098765432109876543210
7894                                                                  010001x0101xxxxx1110x0xxxxxxxxxx
7895                                                                  sqdmullb.  */
7896                                                               return 2186;
7897                                                             }
7898                                                           else
7899                                                             {
7900                                                               if (((word >> 11) & 0x1) == 0)
7901                                                                 {
7902                                                                   /* 33222222222211111111110000000000
7903                                                                      10987654321098765432109876543210
7904                                                                      010001x0101xxxxx111100xxxxxxxxxx
7905                                                                      sqdmulh.  */
7906                                                                   return 2183;
7907                                                                 }
7908                                                               else
7909                                                                 {
7910                                                                   /* 33222222222211111111110000000000
7911                                                                      10987654321098765432109876543210
7912                                                                      010001x0101xxxxx111110xxxxxxxxxx
7913                                                                      mul.  */
7914                                                                   return 2110;
7915                                                                 }
7916                                                             }
7917                                                         }
7918                                                       else
7919                                                         {
7920                                                           if (((word >> 12) & 0x1) == 0)
7921                                                             {
7922                                                               /* 33222222222211111111110000000000
7923                                                                  10987654321098765432109876543210
7924                                                                  010001x0101xxxxx1110x1xxxxxxxxxx
7925                                                                  sqdmullt.  */
7926                                                               return 2189;
7927                                                             }
7928                                                           else
7929                                                             {
7930                                                               /* 33222222222211111111110000000000
7931                                                                  10987654321098765432109876543210
7932                                                                  010001x0101xxxxx1111x1xxxxxxxxxx
7933                                                                  sqrdmulh.  */
7934                                                               return 2205;
7935                                                             }
7936                                                         }
7937                                                     }
7938                                                   else
7939                                                     {
7940                                                       /* 33222222222211111111110000000000
7941                                                          10987654321098765432109876543210
7942                                                          110001x0101xxxxx111xxxxxxxxxxxxx
7943                                                          ldff1h.  */
7944                                                       return 1661;
7945                                                     }
7946                                                 }
7947                                               else
7948                                                 {
7949                                                   if (((word >> 31) & 0x1) == 0)
7950                                                     {
7951                                                       if (((word >> 10) & 0x1) == 0)
7952                                                         {
7953                                                           if (((word >> 12) & 0x1) == 0)
7954                                                             {
7955                                                               /* 33222222222211111111110000000000
7956                                                                  10987654321098765432109876543210
7957                                                                  010001x0111xxxxx1110x0xxxxxxxxxx
7958                                                                  sqdmullb.  */
7959                                                               return 2187;
7960                                                             }
7961                                                           else
7962                                                             {
7963                                                               if (((word >> 11) & 0x1) == 0)
7964                                                                 {
7965                                                                   /* 33222222222211111111110000000000
7966                                                                      10987654321098765432109876543210
7967                                                                      010001x0111xxxxx111100xxxxxxxxxx
7968                                                                      sqdmulh.  */
7969                                                                   return 2184;
7970                                                                 }
7971                                                               else
7972                                                                 {
7973                                                                   /* 33222222222211111111110000000000
7974                                                                      10987654321098765432109876543210
7975                                                                      010001x0111xxxxx111110xxxxxxxxxx
7976                                                                      mul.  */
7977                                                                   return 2111;
7978                                                                 }
7979                                                             }
7980                                                         }
7981                                                       else
7982                                                         {
7983                                                           if (((word >> 12) & 0x1) == 0)
7984                                                             {
7985                                                               /* 33222222222211111111110000000000
7986                                                                  10987654321098765432109876543210
7987                                                                  010001x0111xxxxx1110x1xxxxxxxxxx
7988                                                                  sqdmullt.  */
7989                                                               return 2190;
7990                                                             }
7991                                                           else
7992                                                             {
7993                                                               /* 33222222222211111111110000000000
7994                                                                  10987654321098765432109876543210
7995                                                                  010001x0111xxxxx1111x1xxxxxxxxxx
7996                                                                  sqrdmulh.  */
7997                                                               return 2206;
7998                                                             }
7999                                                         }
8000                                                     }
8001                                                   else
8002                                                     {
8003                                                       /* 33222222222211111111110000000000
8004                                                          10987654321098765432109876543210
8005                                                          110001x0111xxxxx111xxxxxxxxxxxxx
8006                                                          ldff1h.  */
8007                                                       return 1659;
8008                                                     }
8009                                                 }
8010                                             }
8011                                         }
8012                                     }
8013                                 }
8014                             }
8015                         }
8016                     }
8017                   else
8018                     {
8019                       if (((word >> 21) & 0x1) == 0)
8020                         {
8021                           if (((word >> 15) & 0x1) == 0)
8022                             {
8023                               if (((word >> 30) & 0x1) == 0)
8024                                 {
8025                                   if (((word >> 13) & 0x1) == 0)
8026                                     {
8027                                       if (((word >> 14) & 0x1) == 0)
8028                                         {
8029                                           if (((word >> 31) & 0x1) == 0)
8030                                             {
8031                                               if (((word >> 4) & 0x1) == 0)
8032                                                 {
8033                                                   /* 33222222222211111111110000000000
8034                                                      10987654321098765432109876543210
8035                                                      001001x0xx0xxxxx000xxxxxxxx0xxxx
8036                                                      cmphs.  */
8037                                                   return 1333;
8038                                                 }
8039                                               else
8040                                                 {
8041                                                   /* 33222222222211111111110000000000
8042                                                      10987654321098765432109876543210
8043                                                      001001x0xx0xxxxx000xxxxxxxx1xxxx
8044                                                      cmphi.  */
8045                                                   return 1330;
8046                                                 }
8047                                             }
8048                                           else
8049                                             {
8050                                               if (((word >> 23) & 0x1) == 0)
8051                                                 {
8052                                                   /* 33222222222211111111110000000000
8053                                                      10987654321098765432109876543210
8054                                                      101001x00x0xxxxx000xxxxxxxxxxxxx
8055                                                      ld1rqb.  */
8056                                                   return 1547;
8057                                                 }
8058                                               else
8059                                                 {
8060                                                   /* 33222222222211111111110000000000
8061                                                      10987654321098765432109876543210
8062                                                      101001x01x0xxxxx000xxxxxxxxxxxxx
8063                                                      ld1rqh.  */
8064                                                   return 1551;
8065                                                 }
8066                                             }
8067                                         }
8068                                       else
8069                                         {
8070                                           if (((word >> 31) & 0x1) == 0)
8071                                             {
8072                                               if (((word >> 4) & 0x1) == 0)
8073                                                 {
8074                                                   /* 33222222222211111111110000000000
8075                                                      10987654321098765432109876543210
8076                                                      001001x0xx0xxxxx010xxxxxxxx0xxxx
8077                                                      cmpge.  */
8078                                                   return 1324;
8079                                                 }
8080                                               else
8081                                                 {
8082                                                   /* 33222222222211111111110000000000
8083                                                      10987654321098765432109876543210
8084                                                      001001x0xx0xxxxx010xxxxxxxx1xxxx
8085                                                      cmpgt.  */
8086                                                   return 1327;
8087                                                 }
8088                                             }
8089                                           else
8090                                             {
8091                                               if (((word >> 22) & 0x1) == 0)
8092                                                 {
8093                                                   if (((word >> 23) & 0x1) == 0)
8094                                                     {
8095                                                       /* 33222222222211111111110000000000
8096                                                          10987654321098765432109876543210
8097                                                          101001x0000xxxxx010xxxxxxxxxxxxx
8098                                                          ld1b.  */
8099                                                       return 1505;
8100                                                     }
8101                                                   else
8102                                                     {
8103                                                       /* 33222222222211111111110000000000
8104                                                          10987654321098765432109876543210
8105                                                          101001x0100xxxxx010xxxxxxxxxxxxx
8106                                                          ld1sw.  */
8107                                                       return 1585;
8108                                                     }
8109                                                 }
8110                                               else
8111                                                 {
8112                                                   if (((word >> 23) & 0x1) == 0)
8113                                                     {
8114                                                       /* 33222222222211111111110000000000
8115                                                          10987654321098765432109876543210
8116                                                          101001x0010xxxxx010xxxxxxxxxxxxx
8117                                                          ld1b.  */
8118                                                       return 1507;
8119                                                     }
8120                                                   else
8121                                                     {
8122                                                       /* 33222222222211111111110000000000
8123                                                          10987654321098765432109876543210
8124                                                          101001x0110xxxxx010xxxxxxxxxxxxx
8125                                                          ld1h.  */
8126                                                       return 1527;
8127                                                     }
8128                                                 }
8129                                             }
8130                                         }
8131                                     }
8132                                   else
8133                                     {
8134                                       if (((word >> 14) & 0x1) == 0)
8135                                         {
8136                                           if (((word >> 31) & 0x1) == 0)
8137                                             {
8138                                               if (((word >> 4) & 0x1) == 0)
8139                                                 {
8140                                                   /* 33222222222211111111110000000000
8141                                                      10987654321098765432109876543210
8142                                                      001001x0xx0xxxxx001xxxxxxxx0xxxx
8143                                                      cmpeq.  */
8144                                                   return 1321;
8145                                                 }
8146                                               else
8147                                                 {
8148                                                   /* 33222222222211111111110000000000
8149                                                      10987654321098765432109876543210
8150                                                      001001x0xx0xxxxx001xxxxxxxx1xxxx
8151                                                      cmpne.  */
8152                                                   return 1344;
8153                                                 }
8154                                             }
8155                                           else
8156                                             {
8157                                               if (((word >> 23) & 0x1) == 0)
8158                                                 {
8159                                                   /* 33222222222211111111110000000000
8160                                                      10987654321098765432109876543210
8161                                                      101001x00x0xxxxx001xxxxxxxxxxxxx
8162                                                      ld1rqb.  */
8163                                                   return 1546;
8164                                                 }
8165                                               else
8166                                                 {
8167                                                   /* 33222222222211111111110000000000
8168                                                      10987654321098765432109876543210
8169                                                      101001x01x0xxxxx001xxxxxxxxxxxxx
8170                                                      ld1rqh.  */
8171                                                   return 1550;
8172                                                 }
8173                                             }
8174                                         }
8175                                       else
8176                                         {
8177                                           if (((word >> 31) & 0x1) == 0)
8178                                             {
8179                                               if (((word >> 4) & 0x1) == 0)
8180                                                 {
8181                                                   /* 33222222222211111111110000000000
8182                                                      10987654321098765432109876543210
8183                                                      001001x0xx0xxxxx011xxxxxxxx0xxxx
8184                                                      cmplt.  */
8185                                                   return 1342;
8186                                                 }
8187                                               else
8188                                                 {
8189                                                   /* 33222222222211111111110000000000
8190                                                      10987654321098765432109876543210
8191                                                      001001x0xx0xxxxx011xxxxxxxx1xxxx
8192                                                      cmple.  */
8193                                                   return 1336;
8194                                                 }
8195                                             }
8196                                           else
8197                                             {
8198                                               if (((word >> 22) & 0x1) == 0)
8199                                                 {
8200                                                   if (((word >> 23) & 0x1) == 0)
8201                                                     {
8202                                                       /* 33222222222211111111110000000000
8203                                                          10987654321098765432109876543210
8204                                                          101001x0000xxxxx011xxxxxxxxxxxxx
8205                                                          ldff1b.  */
8206                                                       return 1629;
8207                                                     }
8208                                                   else
8209                                                     {
8210                                                       /* 33222222222211111111110000000000
8211                                                          10987654321098765432109876543210
8212                                                          101001x0100xxxxx011xxxxxxxxxxxxx
8213                                                          ldff1sw.  */
8214                                                       return 1685;
8215                                                     }
8216                                                 }
8217                                               else
8218                                                 {
8219                                                   if (((word >> 23) & 0x1) == 0)
8220                                                     {
8221                                                       /* 33222222222211111111110000000000
8222                                                          10987654321098765432109876543210
8223                                                          101001x0010xxxxx011xxxxxxxxxxxxx
8224                                                          ldff1b.  */
8225                                                       return 1633;
8226                                                     }
8227                                                   else
8228                                                     {
8229                                                       /* 33222222222211111111110000000000
8230                                                          10987654321098765432109876543210
8231                                                          101001x0110xxxxx011xxxxxxxxxxxxx
8232                                                          ldff1h.  */
8233                                                       return 1652;
8234                                                     }
8235                                                 }
8236                                             }
8237                                         }
8238                                     }
8239                                 }
8240                               else
8241                                 {
8242                                   if (((word >> 31) & 0x1) == 0)
8243                                     {
8244                                       /* 33222222222211111111110000000000
8245                                          10987654321098765432109876543210
8246                                          011001x0xx0xxxxx0xxxxxxxxxxxxxxx
8247                                          fcmla.  */
8248                                       return 1390;
8249                                     }
8250                                   else
8251                                     {
8252                                       if (((word >> 13) & 0x1) == 0)
8253                                         {
8254                                           if (((word >> 22) & 0x1) == 0)
8255                                             {
8256                                               /* 33222222222211111111110000000000
8257                                                  10987654321098765432109876543210
8258                                                  111001x0x00xxxxx0x0xxxxxxxxxxxxx
8259                                                  st1b.  */
8260                                               return 1867;
8261                                             }
8262                                           else
8263                                             {
8264                                               if (((word >> 23) & 0x1) == 0)
8265                                                 {
8266                                                   /* 33222222222211111111110000000000
8267                                                      10987654321098765432109876543210
8268                                                      111001x0010xxxxx0x0xxxxxxxxxxxxx
8269                                                      st1b.  */
8270                                                   return 1871;
8271                                                 }
8272                                               else
8273                                                 {
8274                                                   /* 33222222222211111111110000000000
8275                                                      10987654321098765432109876543210
8276                                                      111001x0110xxxxx0x0xxxxxxxxxxxxx
8277                                                      st1h.  */
8278                                                   return 1892;
8279                                                 }
8280                                             }
8281                                         }
8282                                       else
8283                                         {
8284                                           if (((word >> 14) & 0x1) == 0)
8285                                             {
8286                                               if (((word >> 22) & 0x1) == 0)
8287                                                 {
8288                                                   if (((word >> 23) & 0x1) == 0)
8289                                                     {
8290                                                       /* 33222222222211111111110000000000
8291                                                          10987654321098765432109876543210
8292                                                          111001x0000xxxxx001xxxxxxxxxxxxx
8293                                                          stnt1b.  */
8294                                                       return 2244;
8295                                                     }
8296                                                   else
8297                                                     {
8298                                                       /* 33222222222211111111110000000000
8299                                                          10987654321098765432109876543210
8300                                                          111001x0100xxxxx001xxxxxxxxxxxxx
8301                                                          stnt1h.  */
8302                                                       return 2247;
8303                                                     }
8304                                                 }
8305                                               else
8306                                                 {
8307                                                   if (((word >> 23) & 0x1) == 0)
8308                                                     {
8309                                                       /* 33222222222211111111110000000000
8310                                                          10987654321098765432109876543210
8311                                                          111001x0010xxxxx001xxxxxxxxxxxxx
8312                                                          stnt1b.  */
8313                                                       return 2243;
8314                                                     }
8315                                                   else
8316                                                     {
8317                                                       /* 33222222222211111111110000000000
8318                                                          10987654321098765432109876543210
8319                                                          111001x0110xxxxx001xxxxxxxxxxxxx
8320                                                          stnt1h.  */
8321                                                       return 2246;
8322                                                     }
8323                                                 }
8324                                             }
8325                                           else
8326                                             {
8327                                               if (((word >> 22) & 0x1) == 0)
8328                                                 {
8329                                                   if (((word >> 23) & 0x1) == 0)
8330                                                     {
8331                                                       /* 33222222222211111111110000000000
8332                                                          10987654321098765432109876543210
8333                                                          111001x0000xxxxx011xxxxxxxxxxxxx
8334                                                          stnt1b.  */
8335                                                       return 1937;
8336                                                     }
8337                                                   else
8338                                                     {
8339                                                       /* 33222222222211111111110000000000
8340                                                          10987654321098765432109876543210
8341                                                          111001x0100xxxxx011xxxxxxxxxxxxx
8342                                                          stnt1h.  */
8343                                                       return 1941;
8344                                                     }
8345                                                 }
8346                                               else
8347                                                 {
8348                                                   if (((word >> 23) & 0x1) == 0)
8349                                                     {
8350                                                       /* 33222222222211111111110000000000
8351                                                          10987654321098765432109876543210
8352                                                          111001x0010xxxxx011xxxxxxxxxxxxx
8353                                                          st3b.  */
8354                                                       return 1921;
8355                                                     }
8356                                                   else
8357                                                     {
8358                                                       /* 33222222222211111111110000000000
8359                                                          10987654321098765432109876543210
8360                                                          111001x0110xxxxx011xxxxxxxxxxxxx
8361                                                          st3h.  */
8362                                                       return 1925;
8363                                                     }
8364                                                 }
8365                                             }
8366                                         }
8367                                     }
8368                                 }
8369                             }
8370                           else
8371                             {
8372                               if (((word >> 13) & 0x1) == 0)
8373                                 {
8374                                   if (((word >> 30) & 0x1) == 0)
8375                                     {
8376                                       if (((word >> 14) & 0x1) == 0)
8377                                         {
8378                                           if (((word >> 4) & 0x1) == 0)
8379                                             {
8380                                               /* 33222222222211111111110000000000
8381                                                  10987654321098765432109876543210
8382                                                  x01001x0xx0xxxxx100xxxxxxxx0xxxx
8383                                                  cmpge.  */
8384                                               return 1325;
8385                                             }
8386                                           else
8387                                             {
8388                                               /* 33222222222211111111110000000000
8389                                                  10987654321098765432109876543210
8390                                                  x01001x0xx0xxxxx100xxxxxxxx1xxxx
8391                                                  cmpgt.  */
8392                                               return 1328;
8393                                             }
8394                                         }
8395                                       else
8396                                         {
8397                                           if (((word >> 31) & 0x1) == 0)
8398                                             {
8399                                               if (((word >> 4) & 0x1) == 0)
8400                                                 {
8401                                                   /* 33222222222211111111110000000000
8402                                                      10987654321098765432109876543210
8403                                                      001001x0xx0xxxxx110xxxxxxxx0xxxx
8404                                                      cmphs.  */
8405                                                   return 1334;
8406                                                 }
8407                                               else
8408                                                 {
8409                                                   /* 33222222222211111111110000000000
8410                                                      10987654321098765432109876543210
8411                                                      001001x0xx0xxxxx110xxxxxxxx1xxxx
8412                                                      cmphi.  */
8413                                                   return 1331;
8414                                                 }
8415                                             }
8416                                           else
8417                                             {
8418                                               if (((word >> 22) & 0x1) == 0)
8419                                                 {
8420                                                   if (((word >> 23) & 0x1) == 0)
8421                                                     {
8422                                                       /* 33222222222211111111110000000000
8423                                                          10987654321098765432109876543210
8424                                                          101001x0000xxxxx110xxxxxxxxxxxxx
8425                                                          ldnt1b.  */
8426                                                       return 1720;
8427                                                     }
8428                                                   else
8429                                                     {
8430                                                       /* 33222222222211111111110000000000
8431                                                          10987654321098765432109876543210
8432                                                          101001x0100xxxxx110xxxxxxxxxxxxx
8433                                                          ldnt1h.  */
8434                                                       return 1724;
8435                                                     }
8436                                                 }
8437                                               else
8438                                                 {
8439                                                   if (((word >> 23) & 0x1) == 0)
8440                                                     {
8441                                                       /* 33222222222211111111110000000000
8442                                                          10987654321098765432109876543210
8443                                                          101001x0010xxxxx110xxxxxxxxxxxxx
8444                                                          ld3b.  */
8445                                                       return 1612;
8446                                                     }
8447                                                   else
8448                                                     {
8449                                                       /* 33222222222211111111110000000000
8450                                                          10987654321098765432109876543210
8451                                                          101001x0110xxxxx110xxxxxxxxxxxxx
8452                                                          ld3h.  */
8453                                                       return 1616;
8454                                                     }
8455                                                 }
8456                                             }
8457                                         }
8458                                     }
8459                                   else
8460                                     {
8461                                       if (((word >> 31) & 0x1) == 0)
8462                                         {
8463                                           if (((word >> 17) & 0x1) == 0)
8464                                             {
8465                                               if (((word >> 18) & 0x1) == 0)
8466                                                 {
8467                                                   if (((word >> 20) & 0x1) == 0)
8468                                                     {
8469                                                       /* 33222222222211111111110000000000
8470                                                          10987654321098765432109876543210
8471                                                          011001x0xx00x00x1x0xxxxxxxxxxxxx
8472                                                          fcadd.  */
8473                                                       return 1389;
8474                                                     }
8475                                                   else
8476                                                     {
8477                                                       /* 33222222222211111111110000000000
8478                                                          10987654321098765432109876543210
8479                                                          011001x0xx01x00x1x0xxxxxxxxxxxxx
8480                                                          faddp.  */
8481                                                       return 2070;
8482                                                     }
8483                                                 }
8484                                               else
8485                                                 {
8486                                                   if (((word >> 16) & 0x1) == 0)
8487                                                     {
8488                                                       /* 33222222222211111111110000000000
8489                                                          10987654321098765432109876543210
8490                                                          011001x0xx0xx1001x0xxxxxxxxxxxxx
8491                                                          fmaxnmp.  */
8492                                                       return 2078;
8493                                                     }
8494                                                   else
8495                                                     {
8496                                                       /* 33222222222211111111110000000000
8497                                                          10987654321098765432109876543210
8498                                                          011001x0xx0xx1011x0xxxxxxxxxxxxx
8499                                                          fminnmp.  */
8500                                                       return 2080;
8501                                                     }
8502                                                 }
8503                                             }
8504                                           else
8505                                             {
8506                                               if (((word >> 16) & 0x1) == 0)
8507                                                 {
8508                                                   /* 33222222222211111111110000000000
8509                                                      10987654321098765432109876543210
8510                                                      011001x0xx0xxx101x0xxxxxxxxxxxxx
8511                                                      fmaxp.  */
8512                                                   return 2079;
8513                                                 }
8514                                               else
8515                                                 {
8516                                                   /* 33222222222211111111110000000000
8517                                                      10987654321098765432109876543210
8518                                                      011001x0xx0xxx111x0xxxxxxxxxxxxx
8519                                                      fminp.  */
8520                                                   return 2081;
8521                                                 }
8522                                             }
8523                                         }
8524                                       else
8525                                         {
8526                                           if (((word >> 22) & 0x1) == 0)
8527                                             {
8528                                               if (((word >> 23) & 0x1) == 0)
8529                                                 {
8530                                                   /* 33222222222211111111110000000000
8531                                                      10987654321098765432109876543210
8532                                                      111001x0000xxxxx1x0xxxxxxxxxxxxx
8533                                                      st1b.  */
8534                                                   return 1868;
8535                                                 }
8536                                               else
8537                                                 {
8538                                                   /* 33222222222211111111110000000000
8539                                                      10987654321098765432109876543210
8540                                                      111001x0100xxxxx1x0xxxxxxxxxxxxx
8541                                                      st1h.  */
8542                                                   return 1887;
8543                                                 }
8544                                             }
8545                                           else
8546                                             {
8547                                               if (((word >> 23) & 0x1) == 0)
8548                                                 {
8549                                                   /* 33222222222211111111110000000000
8550                                                      10987654321098765432109876543210
8551                                                      111001x0010xxxxx1x0xxxxxxxxxxxxx
8552                                                      st1b.  */
8553                                                   return 1872;
8554                                                 }
8555                                               else
8556                                                 {
8557                                                   /* 33222222222211111111110000000000
8558                                                      10987654321098765432109876543210
8559                                                      111001x0110xxxxx1x0xxxxxxxxxxxxx
8560                                                      st1h.  */
8561                                                   return 1893;
8562                                                 }
8563                                             }
8564                                         }
8565                                     }
8566                                 }
8567                               else
8568                                 {
8569                                   if (((word >> 14) & 0x1) == 0)
8570                                     {
8571                                       if (((word >> 30) & 0x1) == 0)
8572                                         {
8573                                           if (((word >> 31) & 0x1) == 0)
8574                                             {
8575                                               if (((word >> 4) & 0x1) == 0)
8576                                                 {
8577                                                   /* 33222222222211111111110000000000
8578                                                      10987654321098765432109876543210
8579                                                      001001x0xx0xxxxx101xxxxxxxx0xxxx
8580                                                      cmpeq.  */
8581                                                   return 1322;
8582                                                 }
8583                                               else
8584                                                 {
8585                                                   /* 33222222222211111111110000000000
8586                                                      10987654321098765432109876543210
8587                                                      001001x0xx0xxxxx101xxxxxxxx1xxxx
8588                                                      cmpne.  */
8589                                                   return 1345;
8590                                                 }
8591                                             }
8592                                           else
8593                                             {
8594                                               if (((word >> 20) & 0x1) == 0)
8595                                                 {
8596                                                   if (((word >> 22) & 0x1) == 0)
8597                                                     {
8598                                                       if (((word >> 23) & 0x1) == 0)
8599                                                         {
8600                                                           /* 33222222222211111111110000000000
8601                                                              10987654321098765432109876543210
8602                                                              101001x00000xxxx101xxxxxxxxxxxxx
8603                                                              ld1b.  */
8604                                                           return 1512;
8605                                                         }
8606                                                       else
8607                                                         {
8608                                                           /* 33222222222211111111110000000000
8609                                                              10987654321098765432109876543210
8610                                                              101001x01000xxxx101xxxxxxxxxxxxx
8611                                                              ld1sw.  */
8612                                                           return 1590;
8613                                                         }
8614                                                     }
8615                                                   else
8616                                                     {
8617                                                       if (((word >> 23) & 0x1) == 0)
8618                                                         {
8619                                                           /* 33222222222211111111110000000000
8620                                                              10987654321098765432109876543210
8621                                                              101001x00100xxxx101xxxxxxxxxxxxx
8622                                                              ld1b.  */
8623                                                           return 1514;
8624                                                         }
8625                                                       else
8626                                                         {
8627                                                           /* 33222222222211111111110000000000
8628                                                              10987654321098765432109876543210
8629                                                              101001x01100xxxx101xxxxxxxxxxxxx
8630                                                              ld1h.  */
8631                                                           return 1535;
8632                                                         }
8633                                                     }
8634                                                 }
8635                                               else
8636                                                 {
8637                                                   if (((word >> 22) & 0x1) == 0)
8638                                                     {
8639                                                       if (((word >> 23) & 0x1) == 0)
8640                                                         {
8641                                                           /* 33222222222211111111110000000000
8642                                                              10987654321098765432109876543210
8643                                                              101001x00001xxxx101xxxxxxxxxxxxx
8644                                                              ldnf1b.  */
8645                                                           return 1704;
8646                                                         }
8647                                                       else
8648                                                         {
8649                                                           /* 33222222222211111111110000000000
8650                                                              10987654321098765432109876543210
8651                                                              101001x01001xxxx101xxxxxxxxxxxxx
8652                                                              ldnf1sw.  */
8653                                                           return 1717;
8654                                                         }
8655                                                     }
8656                                                   else
8657                                                     {
8658                                                       if (((word >> 23) & 0x1) == 0)
8659                                                         {
8660                                                           /* 33222222222211111111110000000000
8661                                                              10987654321098765432109876543210
8662                                                              101001x00101xxxx101xxxxxxxxxxxxx
8663                                                              ldnf1b.  */
8664                                                           return 1706;
8665                                                         }
8666                                                       else
8667                                                         {
8668                                                           /* 33222222222211111111110000000000
8669                                                              10987654321098765432109876543210
8670                                                              101001x01101xxxx101xxxxxxxxxxxxx
8671                                                              ldnf1h.  */
8672                                                           return 1710;
8673                                                         }
8674                                                     }
8675                                                 }
8676                                             }
8677                                         }
8678                                       else
8679                                         {
8680                                           if (((word >> 22) & 0x1) == 0)
8681                                             {
8682                                               if (((word >> 23) & 0x1) == 0)
8683                                                 {
8684                                                   if (((word >> 31) & 0x1) == 0)
8685                                                     {
8686                                                       /* 33222222222211111111110000000000
8687                                                          10987654321098765432109876543210
8688                                                          011001x0000xxxxx101xxxxxxxxxxxxx
8689                                                          fcvtxnt.  */
8690                                                       return 2076;
8691                                                     }
8692                                                   else
8693                                                     {
8694                                                       /* 33222222222211111111110000000000
8695                                                          10987654321098765432109876543210
8696                                                          111001x0000xxxxx101xxxxxxxxxxxxx
8697                                                          st1b.  */
8698                                                       return 1869;
8699                                                     }
8700                                                 }
8701                                               else
8702                                                 {
8703                                                   if (((word >> 31) & 0x1) == 0)
8704                                                     {
8705                                                       if (((word >> 16) & 0x1) == 0)
8706                                                         {
8707                                                           if (((word >> 17) & 0x1) == 0)
8708                                                             {
8709                                                               /* 33222222222211111111110000000000
8710                                                                  10987654321098765432109876543210
8711                                                                  011001x0100xxx00101xxxxxxxxxxxxx
8712                                                                  fcvtnt.  */
8713                                                               return 2073;
8714                                                             }
8715                                                           else
8716                                                             {
8717                                                               /* 33222222222211111111110000000000
8718                                                                  10987654321098765432109876543210
8719                                                                  011001x0100xxx10101xxxxxxxxxxxxx
8720                                                                  bfcvtnt.  */
8721                                                               return 2426;
8722                                                             }
8723                                                         }
8724                                                       else
8725                                                         {
8726                                                           /* 33222222222211111111110000000000
8727                                                              10987654321098765432109876543210
8728                                                              011001x0100xxxx1101xxxxxxxxxxxxx
8729                                                              fcvtlt.  */
8730                                                           return 2071;
8731                                                         }
8732                                                     }
8733                                                   else
8734                                                     {
8735                                                       /* 33222222222211111111110000000000
8736                                                          10987654321098765432109876543210
8737                                                          111001x0100xxxxx101xxxxxxxxxxxxx
8738                                                          st1h.  */
8739                                                       return 1888;
8740                                                     }
8741                                                 }
8742                                             }
8743                                           else
8744                                             {
8745                                               if (((word >> 23) & 0x1) == 0)
8746                                                 {
8747                                                   /* 33222222222211111111110000000000
8748                                                      10987654321098765432109876543210
8749                                                      x11001x0010xxxxx101xxxxxxxxxxxxx
8750                                                      st1b.  */
8751                                                   return 1876;
8752                                                 }
8753                                               else
8754                                                 {
8755                                                   if (((word >> 31) & 0x1) == 0)
8756                                                     {
8757                                                       if (((word >> 16) & 0x1) == 0)
8758                                                         {
8759                                                           /* 33222222222211111111110000000000
8760                                                              10987654321098765432109876543210
8761                                                              011001x0110xxxx0101xxxxxxxxxxxxx
8762                                                              fcvtnt.  */
8763                                                           return 2074;
8764                                                         }
8765                                                       else
8766                                                         {
8767                                                           /* 33222222222211111111110000000000
8768                                                              10987654321098765432109876543210
8769                                                              011001x0110xxxx1101xxxxxxxxxxxxx
8770                                                              fcvtlt.  */
8771                                                           return 2072;
8772                                                         }
8773                                                     }
8774                                                   else
8775                                                     {
8776                                                       /* 33222222222211111111110000000000
8777                                                          10987654321098765432109876543210
8778                                                          111001x0110xxxxx101xxxxxxxxxxxxx
8779                                                          st1h.  */
8780                                                       return 1897;
8781                                                     }
8782                                                 }
8783                                             }
8784                                         }
8785                                     }
8786                                   else
8787                                     {
8788                                       if (((word >> 30) & 0x1) == 0)
8789                                         {
8790                                           if (((word >> 31) & 0x1) == 0)
8791                                             {
8792                                               if (((word >> 4) & 0x1) == 0)
8793                                                 {
8794                                                   /* 33222222222211111111110000000000
8795                                                      10987654321098765432109876543210
8796                                                      001001x0xx0xxxxx111xxxxxxxx0xxxx
8797                                                      cmplo.  */
8798                                                   return 1338;
8799                                                 }
8800                                               else
8801                                                 {
8802                                                   /* 33222222222211111111110000000000
8803                                                      10987654321098765432109876543210
8804                                                      001001x0xx0xxxxx111xxxxxxxx1xxxx
8805                                                      cmpls.  */
8806                                                   return 1340;
8807                                                 }
8808                                             }
8809                                           else
8810                                             {
8811                                               if (((word >> 22) & 0x1) == 0)
8812                                                 {
8813                                                   if (((word >> 23) & 0x1) == 0)
8814                                                     {
8815                                                       /* 33222222222211111111110000000000
8816                                                          10987654321098765432109876543210
8817                                                          101001x0000xxxxx111xxxxxxxxxxxxx
8818                                                          ldnt1b.  */
8819                                                       return 1721;
8820                                                     }
8821                                                   else
8822                                                     {
8823                                                       /* 33222222222211111111110000000000
8824                                                          10987654321098765432109876543210
8825                                                          101001x0100xxxxx111xxxxxxxxxxxxx
8826                                                          ldnt1h.  */
8827                                                       return 1725;
8828                                                     }
8829                                                 }
8830                                               else
8831                                                 {
8832                                                   if (((word >> 23) & 0x1) == 0)
8833                                                     {
8834                                                       /* 33222222222211111111110000000000
8835                                                          10987654321098765432109876543210
8836                                                          101001x0010xxxxx111xxxxxxxxxxxxx
8837                                                          ld3b.  */
8838                                                       return 1613;
8839                                                     }
8840                                                   else
8841                                                     {
8842                                                       /* 33222222222211111111110000000000
8843                                                          10987654321098765432109876543210
8844                                                          101001x0110xxxxx111xxxxxxxxxxxxx
8845                                                          ld3h.  */
8846                                                       return 1617;
8847                                                     }
8848                                                 }
8849                                             }
8850                                         }
8851                                       else
8852                                         {
8853                                           if (((word >> 20) & 0x1) == 0)
8854                                             {
8855                                               if (((word >> 22) & 0x1) == 0)
8856                                                 {
8857                                                   /* 33222222222211111111110000000000
8858                                                      10987654321098765432109876543210
8859                                                      x11001x0x000xxxx111xxxxxxxxxxxxx
8860                                                      st1b.  */
8861                                                   return 1874;
8862                                                 }
8863                                               else
8864                                                 {
8865                                                   if (((word >> 23) & 0x1) == 0)
8866                                                     {
8867                                                       /* 33222222222211111111110000000000
8868                                                          10987654321098765432109876543210
8869                                                          x11001x00100xxxx111xxxxxxxxxxxxx
8870                                                          st1b.  */
8871                                                       return 1877;
8872                                                     }
8873                                                   else
8874                                                     {
8875                                                       /* 33222222222211111111110000000000
8876                                                          10987654321098765432109876543210
8877                                                          x11001x01100xxxx111xxxxxxxxxxxxx
8878                                                          st1h.  */
8879                                                       return 1898;
8880                                                     }
8881                                                 }
8882                                             }
8883                                           else
8884                                             {
8885                                               if (((word >> 22) & 0x1) == 0)
8886                                                 {
8887                                                   if (((word >> 23) & 0x1) == 0)
8888                                                     {
8889                                                       /* 33222222222211111111110000000000
8890                                                          10987654321098765432109876543210
8891                                                          x11001x00001xxxx111xxxxxxxxxxxxx
8892                                                          stnt1b.  */
8893                                                       return 1938;
8894                                                     }
8895                                                   else
8896                                                     {
8897                                                       /* 33222222222211111111110000000000
8898                                                          10987654321098765432109876543210
8899                                                          x11001x01001xxxx111xxxxxxxxxxxxx
8900                                                          stnt1h.  */
8901                                                       return 1942;
8902                                                     }
8903                                                 }
8904                                               else
8905                                                 {
8906                                                   if (((word >> 23) & 0x1) == 0)
8907                                                     {
8908                                                       /* 33222222222211111111110000000000
8909                                                          10987654321098765432109876543210
8910                                                          x11001x00101xxxx111xxxxxxxxxxxxx
8911                                                          st3b.  */
8912                                                       return 1922;
8913                                                     }
8914                                                   else
8915                                                     {
8916                                                       /* 33222222222211111111110000000000
8917                                                          10987654321098765432109876543210
8918                                                          x11001x01101xxxx111xxxxxxxxxxxxx
8919                                                          st3h.  */
8920                                                       return 1926;
8921                                                     }
8922                                                 }
8923                                             }
8924                                         }
8925                                     }
8926                                 }
8927                             }
8928                         }
8929                       else
8930                         {
8931                           if (((word >> 13) & 0x1) == 0)
8932                             {
8933                               if (((word >> 30) & 0x1) == 0)
8934                                 {
8935                                   if (((word >> 31) & 0x1) == 0)
8936                                     {
8937                                       if (((word >> 4) & 0x1) == 0)
8938                                         {
8939                                           /* 33222222222211111111110000000000
8940                                              10987654321098765432109876543210
8941                                              001001x0xx1xxxxxxx0xxxxxxxx0xxxx
8942                                              cmphs.  */
8943                                           return 1335;
8944                                         }
8945                                       else
8946                                         {
8947                                           /* 33222222222211111111110000000000
8948                                              10987654321098765432109876543210
8949                                              001001x0xx1xxxxxxx0xxxxxxxx1xxxx
8950                                              cmphi.  */
8951                                           return 1332;
8952                                         }
8953                                     }
8954                                   else
8955                                     {
8956                                       if (((word >> 14) & 0x1) == 0)
8957                                         {
8958                                           if (((word >> 23) & 0x1) == 0)
8959                                             {
8960                                               /* 33222222222211111111110000000000
8961                                                  10987654321098765432109876543210
8962                                                  101001x00x1xxxxxx00xxxxxxxxxxxxx
8963                                                  ld1rob.  */
8964                                               return 2402;
8965                                             }
8966                                           else
8967                                             {
8968                                               /* 33222222222211111111110000000000
8969                                                  10987654321098765432109876543210
8970                                                  101001x01x1xxxxxx00xxxxxxxxxxxxx
8971                                                  ld1roh.  */
8972                                               return 2403;
8973                                             }
8974                                         }
8975                                       else
8976                                         {
8977                                           if (((word >> 15) & 0x1) == 0)
8978                                             {
8979                                               if (((word >> 22) & 0x1) == 0)
8980                                                 {
8981                                                   if (((word >> 23) & 0x1) == 0)
8982                                                     {
8983                                                       /* 33222222222211111111110000000000
8984                                                          10987654321098765432109876543210
8985                                                          101001x0001xxxxx010xxxxxxxxxxxxx
8986                                                          ld1b.  */
8987                                                       return 1506;
8988                                                     }
8989                                                   else
8990                                                     {
8991                                                       /* 33222222222211111111110000000000
8992                                                          10987654321098765432109876543210
8993                                                          101001x0101xxxxx010xxxxxxxxxxxxx
8994                                                          ld1h.  */
8995                                                       return 1526;
8996                                                     }
8997                                                 }
8998                                               else
8999                                                 {
9000                                                   if (((word >> 23) & 0x1) == 0)
9001                                                     {
9002                                                       /* 33222222222211111111110000000000
9003                                                          10987654321098765432109876543210
9004                                                          101001x0011xxxxx010xxxxxxxxxxxxx
9005                                                          ld1b.  */
9006                                                       return 1508;
9007                                                     }
9008                                                   else
9009                                                     {
9010                                                       /* 33222222222211111111110000000000
9011                                                          10987654321098765432109876543210
9012                                                          101001x0111xxxxx010xxxxxxxxxxxxx
9013                                                          ld1h.  */
9014                                                       return 1528;
9015                                                     }
9016                                                 }
9017                                             }
9018                                           else
9019                                             {
9020                                               if (((word >> 22) & 0x1) == 0)
9021                                                 {
9022                                                   if (((word >> 23) & 0x1) == 0)
9023                                                     {
9024                                                       /* 33222222222211111111110000000000
9025                                                          10987654321098765432109876543210
9026                                                          101001x0001xxxxx110xxxxxxxxxxxxx
9027                                                          ld2b.  */
9028                                                       return 1604;
9029                                                     }
9030                                                   else
9031                                                     {
9032                                                       /* 33222222222211111111110000000000
9033                                                          10987654321098765432109876543210
9034                                                          101001x0101xxxxx110xxxxxxxxxxxxx
9035                                                          ld2h.  */
9036                                                       return 1608;
9037                                                     }
9038                                                 }
9039                                               else
9040                                                 {
9041                                                   if (((word >> 23) & 0x1) == 0)
9042                                                     {
9043                                                       /* 33222222222211111111110000000000
9044                                                          10987654321098765432109876543210
9045                                                          101001x0011xxxxx110xxxxxxxxxxxxx
9046                                                          ld4b.  */
9047                                                       return 1620;
9048                                                     }
9049                                                   else
9050                                                     {
9051                                                       /* 33222222222211111111110000000000
9052                                                          10987654321098765432109876543210
9053                                                          101001x0111xxxxx110xxxxxxxxxxxxx
9054                                                          ld4h.  */
9055                                                       return 1624;
9056                                                     }
9057                                                 }
9058                                             }
9059                                         }
9060                                     }
9061                                 }
9062                               else
9063                                 {
9064                                   if (((word >> 15) & 0x1) == 0)
9065                                     {
9066                                       if (((word >> 14) & 0x1) == 0)
9067                                         {
9068                                           if (((word >> 12) & 0x1) == 0)
9069                                             {
9070                                               if (((word >> 10) & 0x1) == 0)
9071                                                 {
9072                                                   if (((word >> 23) & 0x1) == 0)
9073                                                     {
9074                                                       /* 33222222222211111111110000000000
9075                                                          10987654321098765432109876543210
9076                                                          x11001x00x1xxxxx0000x0xxxxxxxxxx
9077                                                          fmla.  */
9078                                                       return 1443;
9079                                                     }
9080                                                   else
9081                                                     {
9082                                                       if (((word >> 22) & 0x1) == 0)
9083                                                         {
9084                                                           /* 33222222222211111111110000000000
9085                                                              10987654321098765432109876543210
9086                                                              x11001x0101xxxxx0000x0xxxxxxxxxx
9087                                                              fmla.  */
9088                                                           return 1444;
9089                                                         }
9090                                                       else
9091                                                         {
9092                                                           /* 33222222222211111111110000000000
9093                                                              10987654321098765432109876543210
9094                                                              x11001x0111xxxxx0000x0xxxxxxxxxx
9095                                                              fmla.  */
9096                                                           return 1445;
9097                                                         }
9098                                                     }
9099                                                 }
9100                                               else
9101                                                 {
9102                                                   if (((word >> 23) & 0x1) == 0)
9103                                                     {
9104                                                       /* 33222222222211111111110000000000
9105                                                          10987654321098765432109876543210
9106                                                          x11001x00x1xxxxx0000x1xxxxxxxxxx
9107                                                          fmls.  */
9108                                                       return 1447;
9109                                                     }
9110                                                   else
9111                                                     {
9112                                                       if (((word >> 22) & 0x1) == 0)
9113                                                         {
9114                                                           /* 33222222222211111111110000000000
9115                                                              10987654321098765432109876543210
9116                                                              x11001x0101xxxxx0000x1xxxxxxxxxx
9117                                                              fmls.  */
9118                                                           return 1448;
9119                                                         }
9120                                                       else
9121                                                         {
9122                                                           /* 33222222222211111111110000000000
9123                                                              10987654321098765432109876543210
9124                                                              x11001x0111xxxxx0000x1xxxxxxxxxx
9125                                                              fmls.  */
9126                                                           return 1449;
9127                                                         }
9128                                                     }
9129                                                 }
9130                                             }
9131                                           else
9132                                             {
9133                                               if (((word >> 22) & 0x1) == 0)
9134                                                 {
9135                                                   /* 33222222222211111111110000000000
9136                                                      10987654321098765432109876543210
9137                                                      x11001x0x01xxxxx0001xxxxxxxxxxxx
9138                                                      fcmla.  */
9139                                                   return 1391;
9140                                                 }
9141                                               else
9142                                                 {
9143                                                   /* 33222222222211111111110000000000
9144                                                      10987654321098765432109876543210
9145                                                      x11001x0x11xxxxx0001xxxxxxxxxxxx
9146                                                      fcmla.  */
9147                                                   return 1392;
9148                                                 }
9149                                             }
9150                                         }
9151                                       else
9152                                         {
9153                                           if (((word >> 22) & 0x1) == 0)
9154                                             {
9155                                               if (((word >> 23) & 0x1) == 0)
9156                                                 {
9157                                                   /* 33222222222211111111110000000000
9158                                                      10987654321098765432109876543210
9159                                                      x11001x0001xxxxx010xxxxxxxxxxxxx
9160                                                      st1b.  */
9161                                                   return 1870;
9162                                                 }
9163                                               else
9164                                                 {
9165                                                   if (((word >> 31) & 0x1) == 0)
9166                                                     {
9167                                                       if (((word >> 10) & 0x1) == 0)
9168                                                         {
9169                                                           /* 33222222222211111111110000000000
9170                                                              10987654321098765432109876543210
9171                                                              011001x0101xxxxx010xx0xxxxxxxxxx
9172                                                              fmlalb.  */
9173                                                           return 2082;
9174                                                         }
9175                                                       else
9176                                                         {
9177                                                           /* 33222222222211111111110000000000
9178                                                              10987654321098765432109876543210
9179                                                              011001x0101xxxxx010xx1xxxxxxxxxx
9180                                                              fmlalt.  */
9181                                                           return 2084;
9182                                                         }
9183                                                     }
9184                                                   else
9185                                                     {
9186                                                       /* 33222222222211111111110000000000
9187                                                          10987654321098765432109876543210
9188                                                          111001x0101xxxxx010xxxxxxxxxxxxx
9189                                                          st1h.  */
9190                                                       return 1889;
9191                                                     }
9192                                                 }
9193                                             }
9194                                           else
9195                                             {
9196                                               if (((word >> 23) & 0x1) == 0)
9197                                                 {
9198                                                   if (((word >> 31) & 0x1) == 0)
9199                                                     {
9200                                                       /* 33222222222211111111110000000000
9201                                                          10987654321098765432109876543210
9202                                                          011001x0011xxxxx010xxxxxxxxxxxxx
9203                                                          bfdot.  */
9204                                                       return 2423;
9205                                                     }
9206                                                   else
9207                                                     {
9208                                                       /* 33222222222211111111110000000000
9209                                                          10987654321098765432109876543210
9210                                                          111001x0011xxxxx010xxxxxxxxxxxxx
9211                                                          st1b.  */
9212                                                       return 1873;
9213                                                     }
9214                                                 }
9215                                               else
9216                                                 {
9217                                                   if (((word >> 31) & 0x1) == 0)
9218                                                     {
9219                                                       if (((word >> 10) & 0x1) == 0)
9220                                                         {
9221                                                           /* 33222222222211111111110000000000
9222                                                              10987654321098765432109876543210
9223                                                              011001x0111xxxxx010xx0xxxxxxxxxx
9224                                                              bfmlalb.  */
9225                                                           return 2430;
9226                                                         }
9227                                                       else
9228                                                         {
9229                                                           /* 33222222222211111111110000000000
9230                                                              10987654321098765432109876543210
9231                                                              011001x0111xxxxx010xx1xxxxxxxxxx
9232                                                              bfmlalt.  */
9233                                                           return 2429;
9234                                                         }
9235                                                     }
9236                                                   else
9237                                                     {
9238                                                       /* 33222222222211111111110000000000
9239                                                          10987654321098765432109876543210
9240                                                          111001x0111xxxxx010xxxxxxxxxxxxx
9241                                                          st1h.  */
9242                                                       return 1894;
9243                                                     }
9244                                                 }
9245                                             }
9246                                         }
9247                                     }
9248                                   else
9249                                     {
9250                                       if (((word >> 22) & 0x1) == 0)
9251                                         {
9252                                           if (((word >> 31) & 0x1) == 0)
9253                                             {
9254                                               if (((word >> 10) & 0x1) == 0)
9255                                                 {
9256                                                   /* 33222222222211111111110000000000
9257                                                      10987654321098765432109876543210
9258                                                      011001x0x01xxxxx1x0xx0xxxxxxxxxx
9259                                                      fmlalb.  */
9260                                                   return 2083;
9261                                                 }
9262                                               else
9263                                                 {
9264                                                   /* 33222222222211111111110000000000
9265                                                      10987654321098765432109876543210
9266                                                      011001x0x01xxxxx1x0xx1xxxxxxxxxx
9267                                                      fmlalt.  */
9268                                                   return 2085;
9269                                                 }
9270                                             }
9271                                           else
9272                                             {
9273                                               /* 33222222222211111111110000000000
9274                                                  10987654321098765432109876543210
9275                                                  111001x0x01xxxxx1x0xxxxxxxxxxxxx
9276                                                  st1h.  */
9277                                               return 1890;
9278                                             }
9279                                         }
9280                                       else
9281                                         {
9282                                           if (((word >> 23) & 0x1) == 0)
9283                                             {
9284                                               /* 33222222222211111111110000000000
9285                                                  10987654321098765432109876543210
9286                                                  x11001x0011xxxxx1x0xxxxxxxxxxxxx
9287                                                  bfdot.  */
9288                                               return 2422;
9289                                             }
9290                                           else
9291                                             {
9292                                               if (((word >> 31) & 0x1) == 0)
9293                                                 {
9294                                                   if (((word >> 10) & 0x1) == 0)
9295                                                     {
9296                                                       /* 33222222222211111111110000000000
9297                                                          10987654321098765432109876543210
9298                                                          011001x0111xxxxx1x0xx0xxxxxxxxxx
9299                                                          bfmlalb.  */
9300                                                       return 2428;
9301                                                     }
9302                                                   else
9303                                                     {
9304                                                       /* 33222222222211111111110000000000
9305                                                          10987654321098765432109876543210
9306                                                          011001x0111xxxxx1x0xx1xxxxxxxxxx
9307                                                          bfmlalt.  */
9308                                                       return 2427;
9309                                                     }
9310                                                 }
9311                                               else
9312                                                 {
9313                                                   /* 33222222222211111111110000000000
9314                                                      10987654321098765432109876543210
9315                                                      111001x0111xxxxx1x0xxxxxxxxxxxxx
9316                                                      st1h.  */
9317                                                   return 1895;
9318                                                 }
9319                                             }
9320                                         }
9321                                     }
9322                                 }
9323                             }
9324                           else
9325                             {
9326                               if (((word >> 30) & 0x1) == 0)
9327                                 {
9328                                   if (((word >> 31) & 0x1) == 0)
9329                                     {
9330                                       if (((word >> 4) & 0x1) == 0)
9331                                         {
9332                                           /* 33222222222211111111110000000000
9333                                              10987654321098765432109876543210
9334                                              001001x0xx1xxxxxxx1xxxxxxxx0xxxx
9335                                              cmplo.  */
9336                                           return 1339;
9337                                         }
9338                                       else
9339                                         {
9340                                           /* 33222222222211111111110000000000
9341                                              10987654321098765432109876543210
9342                                              001001x0xx1xxxxxxx1xxxxxxxx1xxxx
9343                                              cmpls.  */
9344                                           return 1341;
9345                                         }
9346                                     }
9347                                   else
9348                                     {
9349                                       if (((word >> 14) & 0x1) == 0)
9350                                         {
9351                                           if (((word >> 15) & 0x1) == 0)
9352                                             {
9353                                               if (((word >> 23) & 0x1) == 0)
9354                                                 {
9355                                                   /* 33222222222211111111110000000000
9356                                                      10987654321098765432109876543210
9357                                                      101001x00x1xxxxx001xxxxxxxxxxxxx
9358                                                      ld1rob.  */
9359                                                   return 2406;
9360                                                 }
9361                                               else
9362                                                 {
9363                                                   /* 33222222222211111111110000000000
9364                                                      10987654321098765432109876543210
9365                                                      101001x01x1xxxxx001xxxxxxxxxxxxx
9366                                                      ld1roh.  */
9367                                                   return 2407;
9368                                                 }
9369                                             }
9370                                           else
9371                                             {
9372                                               if (((word >> 20) & 0x1) == 0)
9373                                                 {
9374                                                   if (((word >> 22) & 0x1) == 0)
9375                                                     {
9376                                                       if (((word >> 23) & 0x1) == 0)
9377                                                         {
9378                                                           /* 33222222222211111111110000000000
9379                                                              10987654321098765432109876543210
9380                                                              101001x00010xxxx101xxxxxxxxxxxxx
9381                                                              ld1b.  */
9382                                                           return 1513;
9383                                                         }
9384                                                       else
9385                                                         {
9386                                                           /* 33222222222211111111110000000000
9387                                                              10987654321098765432109876543210
9388                                                              101001x01010xxxx101xxxxxxxxxxxxx
9389                                                              ld1h.  */
9390                                                           return 1534;
9391                                                         }
9392                                                     }
9393                                                   else
9394                                                     {
9395                                                       if (((word >> 23) & 0x1) == 0)
9396                                                         {
9397                                                           /* 33222222222211111111110000000000
9398                                                              10987654321098765432109876543210
9399                                                              101001x00110xxxx101xxxxxxxxxxxxx
9400                                                              ld1b.  */
9401                                                           return 1515;
9402                                                         }
9403                                                       else
9404                                                         {
9405                                                           /* 33222222222211111111110000000000
9406                                                              10987654321098765432109876543210
9407                                                              101001x01110xxxx101xxxxxxxxxxxxx
9408                                                              ld1h.  */
9409                                                           return 1536;
9410                                                         }
9411                                                     }
9412                                                 }
9413                                               else
9414                                                 {
9415                                                   if (((word >> 22) & 0x1) == 0)
9416                                                     {
9417                                                       if (((word >> 23) & 0x1) == 0)
9418                                                         {
9419                                                           /* 33222222222211111111110000000000
9420                                                              10987654321098765432109876543210
9421                                                              101001x00011xxxx101xxxxxxxxxxxxx
9422                                                              ldnf1b.  */
9423                                                           return 1705;
9424                                                         }
9425                                                       else
9426                                                         {
9427                                                           /* 33222222222211111111110000000000
9428                                                              10987654321098765432109876543210
9429                                                              101001x01011xxxx101xxxxxxxxxxxxx
9430                                                              ldnf1h.  */
9431                                                           return 1709;
9432                                                         }
9433                                                     }
9434                                                   else
9435                                                     {
9436                                                       if (((word >> 23) & 0x1) == 0)
9437                                                         {
9438                                                           /* 33222222222211111111110000000000
9439                                                              10987654321098765432109876543210
9440                                                              101001x00111xxxx101xxxxxxxxxxxxx
9441                                                              ldnf1b.  */
9442                                                           return 1707;
9443                                                         }
9444                                                       else
9445                                                         {
9446                                                           /* 33222222222211111111110000000000
9447                                                              10987654321098765432109876543210
9448                                                              101001x01111xxxx101xxxxxxxxxxxxx
9449                                                              ldnf1h.  */
9450                                                           return 1711;
9451                                                         }
9452                                                     }
9453                                                 }
9454                                             }
9455                                         }
9456                                       else
9457                                         {
9458                                           if (((word >> 15) & 0x1) == 0)
9459                                             {
9460                                               if (((word >> 22) & 0x1) == 0)
9461                                                 {
9462                                                   if (((word >> 23) & 0x1) == 0)
9463                                                     {
9464                                                       /* 33222222222211111111110000000000
9465                                                          10987654321098765432109876543210
9466                                                          101001x0001xxxxx011xxxxxxxxxxxxx
9467                                                          ldff1b.  */
9468                                                       return 1631;
9469                                                     }
9470                                                   else
9471                                                     {
9472                                                       /* 33222222222211111111110000000000
9473                                                          10987654321098765432109876543210
9474                                                          101001x0101xxxxx011xxxxxxxxxxxxx
9475                                                          ldff1h.  */
9476                                                       return 1650;
9477                                                     }
9478                                                 }
9479                                               else
9480                                                 {
9481                                                   if (((word >> 23) & 0x1) == 0)
9482                                                     {
9483                                                       /* 33222222222211111111110000000000
9484                                                          10987654321098765432109876543210
9485                                                          101001x0011xxxxx011xxxxxxxxxxxxx
9486                                                          ldff1b.  */
9487                                                       return 1635;
9488                                                     }
9489                                                   else
9490                                                     {
9491                                                       /* 33222222222211111111110000000000
9492                                                          10987654321098765432109876543210
9493                                                          101001x0111xxxxx011xxxxxxxxxxxxx
9494                                                          ldff1h.  */
9495                                                       return 1654;
9496                                                     }
9497                                                 }
9498                                             }
9499                                           else
9500                                             {
9501                                               if (((word >> 22) & 0x1) == 0)
9502                                                 {
9503                                                   if (((word >> 23) & 0x1) == 0)
9504                                                     {
9505                                                       /* 33222222222211111111110000000000
9506                                                          10987654321098765432109876543210
9507                                                          101001x0001xxxxx111xxxxxxxxxxxxx
9508                                                          ld2b.  */
9509                                                       return 1605;
9510                                                     }
9511                                                   else
9512                                                     {
9513                                                       /* 33222222222211111111110000000000
9514                                                          10987654321098765432109876543210
9515                                                          101001x0101xxxxx111xxxxxxxxxxxxx
9516                                                          ld2h.  */
9517                                                       return 1609;
9518                                                     }
9519                                                 }
9520                                               else
9521                                                 {
9522                                                   if (((word >> 23) & 0x1) == 0)
9523                                                     {
9524                                                       /* 33222222222211111111110000000000
9525                                                          10987654321098765432109876543210
9526                                                          101001x0011xxxxx111xxxxxxxxxxxxx
9527                                                          ld4b.  */
9528                                                       return 1621;
9529                                                     }
9530                                                   else
9531                                                     {
9532                                                       /* 33222222222211111111110000000000
9533                                                          10987654321098765432109876543210
9534                                                          101001x0111xxxxx111xxxxxxxxxxxxx
9535                                                          ld4h.  */
9536                                                       return 1625;
9537                                                     }
9538                                                 }
9539                                             }
9540                                         }
9541                                     }
9542                                 }
9543                               else
9544                                 {
9545                                   if (((word >> 14) & 0x1) == 0)
9546                                     {
9547                                       if (((word >> 15) & 0x1) == 0)
9548                                         {
9549                                           if (((word >> 23) & 0x1) == 0)
9550                                             {
9551                                               /* 33222222222211111111110000000000
9552                                                  10987654321098765432109876543210
9553                                                  x11001x00x1xxxxx001xxxxxxxxxxxxx
9554                                                  fmul.  */
9555                                               return 1454;
9556                                             }
9557                                           else
9558                                             {
9559                                               if (((word >> 22) & 0x1) == 0)
9560                                                 {
9561                                                   /* 33222222222211111111110000000000
9562                                                      10987654321098765432109876543210
9563                                                      x11001x0101xxxxx001xxxxxxxxxxxxx
9564                                                      fmul.  */
9565                                                   return 1455;
9566                                                 }
9567                                               else
9568                                                 {
9569                                                   /* 33222222222211111111110000000000
9570                                                      10987654321098765432109876543210
9571                                                      x11001x0111xxxxx001xxxxxxxxxxxxx
9572                                                      fmul.  */
9573                                                   return 1456;
9574                                                 }
9575                                             }
9576                                         }
9577                                       else
9578                                         {
9579                                           if (((word >> 22) & 0x1) == 0)
9580                                             {
9581                                               if (((word >> 31) & 0x1) == 0)
9582                                                 {
9583                                                   if (((word >> 10) & 0x1) == 0)
9584                                                     {
9585                                                       /* 33222222222211111111110000000000
9586                                                          10987654321098765432109876543210
9587                                                          011001x0x01xxxxx101xx0xxxxxxxxxx
9588                                                          fmlslb.  */
9589                                                       return 2087;
9590                                                     }
9591                                                   else
9592                                                     {
9593                                                       /* 33222222222211111111110000000000
9594                                                          10987654321098765432109876543210
9595                                                          011001x0x01xxxxx101xx1xxxxxxxxxx
9596                                                          fmlslt.  */
9597                                                       return 2089;
9598                                                     }
9599                                                 }
9600                                               else
9601                                                 {
9602                                                   /* 33222222222211111111110000000000
9603                                                      10987654321098765432109876543210
9604                                                      111001x0x01xxxxx101xxxxxxxxxxxxx
9605                                                      st1h.  */
9606                                                   return 1891;
9607                                                 }
9608                                             }
9609                                           else
9610                                             {
9611                                               if (((word >> 23) & 0x1) == 0)
9612                                                 {
9613                                                   /* 33222222222211111111110000000000
9614                                                      10987654321098765432109876543210
9615                                                      x11001x0011xxxxx101xxxxxxxxxxxxx
9616                                                      st1b.  */
9617                                                   return 1878;
9618                                                 }
9619                                               else
9620                                                 {
9621                                                   /* 33222222222211111111110000000000
9622                                                      10987654321098765432109876543210
9623                                                      x11001x0111xxxxx101xxxxxxxxxxxxx
9624                                                      st1h.  */
9625                                                   return 1899;
9626                                                 }
9627                                             }
9628                                         }
9629                                     }
9630                                   else
9631                                     {
9632                                       if (((word >> 15) & 0x1) == 0)
9633                                         {
9634                                           if (((word >> 22) & 0x1) == 0)
9635                                             {
9636                                               if (((word >> 23) & 0x1) == 0)
9637                                                 {
9638                                                   /* 33222222222211111111110000000000
9639                                                      10987654321098765432109876543210
9640                                                      x11001x0001xxxxx011xxxxxxxxxxxxx
9641                                                      st2b.  */
9642                                                   return 1913;
9643                                                 }
9644                                               else
9645                                                 {
9646                                                   if (((word >> 31) & 0x1) == 0)
9647                                                     {
9648                                                       if (((word >> 10) & 0x1) == 0)
9649                                                         {
9650                                                           /* 33222222222211111111110000000000
9651                                                              10987654321098765432109876543210
9652                                                              011001x0101xxxxx011xx0xxxxxxxxxx
9653                                                              fmlslb.  */
9654                                                           return 2086;
9655                                                         }
9656                                                       else
9657                                                         {
9658                                                           /* 33222222222211111111110000000000
9659                                                              10987654321098765432109876543210
9660                                                              011001x0101xxxxx011xx1xxxxxxxxxx
9661                                                              fmlslt.  */
9662                                                           return 2088;
9663                                                         }
9664                                                     }
9665                                                   else
9666                                                     {
9667                                                       /* 33222222222211111111110000000000
9668                                                          10987654321098765432109876543210
9669                                                          111001x0101xxxxx011xxxxxxxxxxxxx
9670                                                          st2h.  */
9671                                                       return 1917;
9672                                                     }
9673                                                 }
9674                                             }
9675                                           else
9676                                             {
9677                                               if (((word >> 23) & 0x1) == 0)
9678                                                 {
9679                                                   /* 33222222222211111111110000000000
9680                                                      10987654321098765432109876543210
9681                                                      x11001x0011xxxxx011xxxxxxxxxxxxx
9682                                                      st4b.  */
9683                                                   return 1929;
9684                                                 }
9685                                               else
9686                                                 {
9687                                                   /* 33222222222211111111110000000000
9688                                                      10987654321098765432109876543210
9689                                                      x11001x0111xxxxx011xxxxxxxxxxxxx
9690                                                      st4h.  */
9691                                                   return 1933;
9692                                                 }
9693                                             }
9694                                         }
9695                                       else
9696                                         {
9697                                           if (((word >> 22) & 0x1) == 0)
9698                                             {
9699                                               if (((word >> 23) & 0x1) == 0)
9700                                                 {
9701                                                   if (((word >> 20) & 0x1) == 0)
9702                                                     {
9703                                                       /* 33222222222211111111110000000000
9704                                                          10987654321098765432109876543210
9705                                                          x11001x00010xxxx111xxxxxxxxxxxxx
9706                                                          st1b.  */
9707                                                       return 1875;
9708                                                     }
9709                                                   else
9710                                                     {
9711                                                       /* 33222222222211111111110000000000
9712                                                          10987654321098765432109876543210
9713                                                          x11001x00011xxxx111xxxxxxxxxxxxx
9714                                                          st2b.  */
9715                                                       return 1914;
9716                                                     }
9717                                                 }
9718                                               else
9719                                                 {
9720                                                   if (((word >> 31) & 0x1) == 0)
9721                                                     {
9722                                                       /* 33222222222211111111110000000000
9723                                                          10987654321098765432109876543210
9724                                                          011001x0101xxxxx111xxxxxxxxxxxxx
9725                                                          fmmla.  */
9726                                                       return 2400;
9727                                                     }
9728                                                   else
9729                                                     {
9730                                                       if (((word >> 20) & 0x1) == 0)
9731                                                         {
9732                                                           /* 33222222222211111111110000000000
9733                                                              10987654321098765432109876543210
9734                                                              111001x01010xxxx111xxxxxxxxxxxxx
9735                                                              st1h.  */
9736                                                           return 1896;
9737                                                         }
9738                                                       else
9739                                                         {
9740                                                           /* 33222222222211111111110000000000
9741                                                              10987654321098765432109876543210
9742                                                              111001x01011xxxx111xxxxxxxxxxxxx
9743                                                              st2h.  */
9744                                                           return 1918;
9745                                                         }
9746                                                     }
9747                                                 }
9748                                             }
9749                                           else
9750                                             {
9751                                               if (((word >> 23) & 0x1) == 0)
9752                                                 {
9753                                                   if (((word >> 31) & 0x1) == 0)
9754                                                     {
9755                                                       /* 33222222222211111111110000000000
9756                                                          10987654321098765432109876543210
9757                                                          011001x0011xxxxx111xxxxxxxxxxxxx
9758                                                          bfmmla.  */
9759                                                       return 2424;
9760                                                     }
9761                                                   else
9762                                                     {
9763                                                       if (((word >> 20) & 0x1) == 0)
9764                                                         {
9765                                                           /* 33222222222211111111110000000000
9766                                                              10987654321098765432109876543210
9767                                                              111001x00110xxxx111xxxxxxxxxxxxx
9768                                                              st1b.  */
9769                                                           return 1879;
9770                                                         }
9771                                                       else
9772                                                         {
9773                                                           /* 33222222222211111111110000000000
9774                                                              10987654321098765432109876543210
9775                                                              111001x00111xxxx111xxxxxxxxxxxxx
9776                                                              st4b.  */
9777                                                           return 1930;
9778                                                         }
9779                                                     }
9780                                                 }
9781                                               else
9782                                                 {
9783                                                   if (((word >> 31) & 0x1) == 0)
9784                                                     {
9785                                                       /* 33222222222211111111110000000000
9786                                                          10987654321098765432109876543210
9787                                                          011001x0111xxxxx111xxxxxxxxxxxxx
9788                                                          fmmla.  */
9789                                                       return 2401;
9790                                                     }
9791                                                   else
9792                                                     {
9793                                                       if (((word >> 20) & 0x1) == 0)
9794                                                         {
9795                                                           /* 33222222222211111111110000000000
9796                                                              10987654321098765432109876543210
9797                                                              111001x01110xxxx111xxxxxxxxxxxxx
9798                                                              st1h.  */
9799                                                           return 1900;
9800                                                         }
9801                                                       else
9802                                                         {
9803                                                           /* 33222222222211111111110000000000
9804                                                              10987654321098765432109876543210
9805                                                              111001x01111xxxx111xxxxxxxxxxxxx
9806                                                              st4h.  */
9807                                                           return 1934;
9808                                                         }
9809                                                     }
9810                                                 }
9811                                             }
9812                                         }
9813                                     }
9814                                 }
9815                             }
9816                         }
9817                     }
9818                 }
9819               else
9820                 {
9821                   if (((word >> 29) & 0x1) == 0)
9822                     {
9823                       if (((word >> 30) & 0x1) == 0)
9824                         {
9825                           if (((word >> 31) & 0x1) == 0)
9826                             {
9827                               if (((word >> 21) & 0x1) == 0)
9828                                 {
9829                                   if (((word >> 20) & 0x1) == 0)
9830                                     {
9831                                       if (((word >> 22) & 0x1) == 0)
9832                                         {
9833                                           if (((word >> 23) & 0x1) == 0)
9834                                             {
9835                                               /* 33222222222211111111110000000000
9836                                                  10987654321098765432109876543210
9837                                                  000001x10000xxxxxxxxxxxxxxxxxxxx
9838                                                  orr.  */
9839                                               return 1759;
9840                                             }
9841                                           else
9842                                             {
9843                                               /* 33222222222211111111110000000000
9844                                                  10987654321098765432109876543210
9845                                                  000001x11000xxxxxxxxxxxxxxxxxxxx
9846                                                  and.  */
9847                                               return 1287;
9848                                             }
9849                                         }
9850                                       else
9851                                         {
9852                                           if (((word >> 23) & 0x1) == 0)
9853                                             {
9854                                               /* 33222222222211111111110000000000
9855                                                  10987654321098765432109876543210
9856                                                  000001x10100xxxxxxxxxxxxxxxxxxxx
9857                                                  eor.  */
9858                                               return 1374;
9859                                             }
9860                                           else
9861                                             {
9862                                               /* 33222222222211111111110000000000
9863                                                  10987654321098765432109876543210
9864                                                  000001x11100xxxxxxxxxxxxxxxxxxxx
9865                                                  dupm.  */
9866                                               return 1372;
9867                                             }
9868                                         }
9869                                     }
9870                                   else
9871                                     {
9872                                       if (((word >> 15) & 0x1) == 0)
9873                                         {
9874                                           /* 33222222222211111111110000000000
9875                                              10987654321098765432109876543210
9876                                              000001x1xx01xxxx0xxxxxxxxxxxxxxx
9877                                              cpy.  */
9878                                           return 1357;
9879                                         }
9880                                       else
9881                                         {
9882                                           /* 33222222222211111111110000000000
9883                                              10987654321098765432109876543210
9884                                              000001x1xx01xxxx1xxxxxxxxxxxxxxx
9885                                              fcpy.  */
9886                                           return 1404;
9887                                         }
9888                                     }
9889                                 }
9890                               else
9891                                 {
9892                                   if (((word >> 14) & 0x1) == 0)
9893                                     {
9894                                       if (((word >> 13) & 0x1) == 0)
9895                                         {
9896                                           if (((word >> 15) & 0x1) == 0)
9897                                             {
9898                                               if (((word >> 22) & 0x1) == 0)
9899                                                 {
9900                                                   if (((word >> 23) & 0x1) == 0)
9901                                                     {
9902                                                       /* 33222222222211111111110000000000
9903                                                          10987654321098765432109876543210
9904                                                          000001x1001xxxxx000xxxxxxxxxxxxx
9905                                                          ext.  */
9906                                                       return 1379;
9907                                                     }
9908                                                   else
9909                                                     {
9910                                                       if (((word >> 10) & 0x1) == 0)
9911                                                         {
9912                                                           if (((word >> 11) & 0x1) == 0)
9913                                                             {
9914                                                               /* 33222222222211111111110000000000
9915                                                                  10987654321098765432109876543210
9916                                                                  000001x1101xxxxx000x00xxxxxxxxxx
9917                                                                  zip1.  */
9918                                                               return 2410;
9919                                                             }
9920                                                           else
9921                                                             {
9922                                                               if (((word >> 12) & 0x1) == 0)
9923                                                                 {
9924                                                                   /* 33222222222211111111110000000000
9925                                                                      10987654321098765432109876543210
9926                                                                      000001x1101xxxxx000010xxxxxxxxxx
9927                                                                      uzp1.  */
9928                                                                   return 2412;
9929                                                                 }
9930                                                               else
9931                                                                 {
9932                                                                   /* 33222222222211111111110000000000
9933                                                                      10987654321098765432109876543210
9934                                                                      000001x1101xxxxx000110xxxxxxxxxx
9935                                                                      trn1.  */
9936                                                                   return 2414;
9937                                                                 }
9938                                                             }
9939                                                         }
9940                                                       else
9941                                                         {
9942                                                           if (((word >> 11) & 0x1) == 0)
9943                                                             {
9944                                                               /* 33222222222211111111110000000000
9945                                                                  10987654321098765432109876543210
9946                                                                  000001x1101xxxxx000x01xxxxxxxxxx
9947                                                                  zip2.  */
9948                                                               return 2411;
9949                                                             }
9950                                                           else
9951                                                             {
9952                                                               if (((word >> 12) & 0x1) == 0)
9953                                                                 {
9954                                                                   /* 33222222222211111111110000000000
9955                                                                      10987654321098765432109876543210
9956                                                                      000001x1101xxxxx000011xxxxxxxxxx
9957                                                                      uzp2.  */
9958                                                                   return 2413;
9959                                                                 }
9960                                                               else
9961                                                                 {
9962                                                                   /* 33222222222211111111110000000000
9963                                                                      10987654321098765432109876543210
9964                                                                      000001x1101xxxxx000111xxxxxxxxxx
9965                                                                      trn2.  */
9966                                                                   return 2415;
9967                                                                 }
9968                                                             }
9969                                                         }
9970                                                     }
9971                                                 }
9972                                               else
9973                                                 {
9974                                                   /* 33222222222211111111110000000000
9975                                                      10987654321098765432109876543210
9976                                                      000001x1x11xxxxx000xxxxxxxxxxxxx
9977                                                      ext.  */
9978                                                   return 2069;
9979                                                 }
9980                                             }
9981                                           else
9982                                             {
9983                                               if (((word >> 16) & 0x1) == 0)
9984                                                 {
9985                                                   if (((word >> 17) & 0x1) == 0)
9986                                                     {
9987                                                       if (((word >> 18) & 0x1) == 0)
9988                                                         {
9989                                                           if (((word >> 19) & 0x1) == 0)
9990                                                             {
9991                                                               /* 33222222222211111111110000000000
9992                                                                  10987654321098765432109876543210
9993                                                                  000001x1xx1x0000100xxxxxxxxxxxxx
9994                                                                  cpy.  */
9995                                                               return 1355;
9996                                                             }
9997                                                           else
9998                                                             {
9999                                                               /* 33222222222211111111110000000000
10000                                                                  10987654321098765432109876543210
10001                                                                  000001x1xx1x1000100xxxxxxxxxxxxx
10002                                                                  clasta.  */
10003                                                               return 1313;
10004                                                             }
10005                                                         }
10006                                                       else
10007                                                         {
10008                                                           if (((word >> 19) & 0x1) == 0)
10009                                                             {
10010                                                               /* 33222222222211111111110000000000
10011                                                                  10987654321098765432109876543210
10012                                                                  000001x1xx1x0100100xxxxxxxxxxxxx
10013                                                                  revb.  */
10014                                                               return 1807;
10015                                                             }
10016                                                           else
10017                                                             {
10018                                                               /* 33222222222211111111110000000000
10019                                                                  10987654321098765432109876543210
10020                                                                  000001x1xx1x1100100xxxxxxxxxxxxx
10021                                                                  splice.  */
10022                                                               return 1834;
10023                                                             }
10024                                                         }
10025                                                     }
10026                                                   else
10027                                                     {
10028                                                       if (((word >> 18) & 0x1) == 0)
10029                                                         {
10030                                                           if (((word >> 19) & 0x1) == 0)
10031                                                             {
10032                                                               /* 33222222222211111111110000000000
10033                                                                  10987654321098765432109876543210
10034                                                                  000001x1xx1x0010100xxxxxxxxxxxxx
10035                                                                  lasta.  */
10036                                                               return 1501;
10037                                                             }
10038                                                           else
10039                                                             {
10040                                                               /* 33222222222211111111110000000000
10041                                                                  10987654321098765432109876543210
10042                                                                  000001x1xx1x1010100xxxxxxxxxxxxx
10043                                                                  clasta.  */
10044                                                               return 1314;
10045                                                             }
10046                                                         }
10047                                                       else
10048                                                         {
10049                                                           /* 33222222222211111111110000000000
10050                                                              10987654321098765432109876543210
10051                                                              000001x1xx1xx110100xxxxxxxxxxxxx
10052                                                              revw.  */
10053                                                           return 1809;
10054                                                         }
10055                                                     }
10056                                                 }
10057                                               else
10058                                                 {
10059                                                   if (((word >> 17) & 0x1) == 0)
10060                                                     {
10061                                                       if (((word >> 18) & 0x1) == 0)
10062                                                         {
10063                                                           if (((word >> 19) & 0x1) == 0)
10064                                                             {
10065                                                               /* 33222222222211111111110000000000
10066                                                                  10987654321098765432109876543210
10067                                                                  000001x1xx1x0001100xxxxxxxxxxxxx
10068                                                                  compact.  */
10069                                                               return 1354;
10070                                                             }
10071                                                           else
10072                                                             {
10073                                                               /* 33222222222211111111110000000000
10074                                                                  10987654321098765432109876543210
10075                                                                  000001x1xx1x1001100xxxxxxxxxxxxx
10076                                                                  clastb.  */
10077                                                               return 1316;
10078                                                             }
10079                                                         }
10080                                                       else
10081                                                         {
10082                                                           if (((word >> 19) & 0x1) == 0)
10083                                                             {
10084                                                               /* 33222222222211111111110000000000
10085                                                                  10987654321098765432109876543210
10086                                                                  000001x1xx1x0101100xxxxxxxxxxxxx
10087                                                                  revh.  */
10088                                                               return 1808;
10089                                                             }
10090                                                           else
10091                                                             {
10092                                                               /* 33222222222211111111110000000000
10093                                                                  10987654321098765432109876543210
10094                                                                  000001x1xx1x1101100xxxxxxxxxxxxx
10095                                                                  splice.  */
10096                                                               return 2164;
10097                                                             }
10098                                                         }
10099                                                     }
10100                                                   else
10101                                                     {
10102                                                       if (((word >> 18) & 0x1) == 0)
10103                                                         {
10104                                                           if (((word >> 19) & 0x1) == 0)
10105                                                             {
10106                                                               /* 33222222222211111111110000000000
10107                                                                  10987654321098765432109876543210
10108                                                                  000001x1xx1x0011100xxxxxxxxxxxxx
10109                                                                  lastb.  */
10110                                                               return 1503;
10111                                                             }
10112                                                           else
10113                                                             {
10114                                                               /* 33222222222211111111110000000000
10115                                                                  10987654321098765432109876543210
10116                                                                  000001x1xx1x1011100xxxxxxxxxxxxx
10117                                                                  clastb.  */
10118                                                               return 1317;
10119                                                             }
10120                                                         }
10121                                                       else
10122                                                         {
10123                                                           /* 33222222222211111111110000000000
10124                                                              10987654321098765432109876543210
10125                                                              000001x1xx1xx111100xxxxxxxxxxxxx
10126                                                              rbit.  */
10127                                                           return 1800;
10128                                                         }
10129                                                     }
10130                                                 }
10131                                             }
10132                                         }
10133                                       else
10134                                         {
10135                                           if (((word >> 15) & 0x1) == 0)
10136                                             {
10137                                               if (((word >> 10) & 0x1) == 0)
10138                                                 {
10139                                                   if (((word >> 11) & 0x1) == 0)
10140                                                     {
10141                                                       if (((word >> 12) & 0x1) == 0)
10142                                                         {
10143                                                           /* 33222222222211111111110000000000
10144                                                              10987654321098765432109876543210
10145                                                              000001x1xx1xxxxx001000xxxxxxxxxx
10146                                                              dup.  */
10147                                                           return 1370;
10148                                                         }
10149                                                       else
10150                                                         {
10151                                                           /* 33222222222211111111110000000000
10152                                                              10987654321098765432109876543210
10153                                                              000001x1xx1xxxxx001100xxxxxxxxxx
10154                                                              tbl.  */
10155                                                           return 1957;
10156                                                         }
10157                                                     }
10158                                                   else
10159                                                     {
10160                                                       if (((word >> 12) & 0x1) == 0)
10161                                                         {
10162                                                           /* 33222222222211111111110000000000
10163                                                              10987654321098765432109876543210
10164                                                              000001x1xx1xxxxx001010xxxxxxxxxx
10165                                                              tbl.  */
10166                                                           return 2253;
10167                                                         }
10168                                                       else
10169                                                         {
10170                                                           if (((word >> 16) & 0x1) == 0)
10171                                                             {
10172                                                               if (((word >> 17) & 0x1) == 0)
10173                                                                 {
10174                                                                   if (((word >> 18) & 0x1) == 0)
10175                                                                     {
10176                                                                       if (((word >> 19) & 0x1) == 0)
10177                                                                         {
10178                                                                           if (((word >> 20) & 0x1) == 0)
10179                                                                             {
10180                                                                               /* 33222222222211111111110000000000
10181                                                                                  10987654321098765432109876543210
10182                                                                                  000001x1xx100000001110xxxxxxxxxx
10183                                                                                  dup.  */
10184                                                                               return 1369;
10185                                                                             }
10186                                                                           else
10187                                                                             {
10188                                                                               /* 33222222222211111111110000000000
10189                                                                                  10987654321098765432109876543210
10190                                                                                  000001x1xx110000001110xxxxxxxxxx
10191                                                                                  sunpklo.  */
10192                                                                               return 1953;
10193                                                                             }
10194                                                                         }
10195                                                                       else
10196                                                                         {
10197                                                                           /* 33222222222211111111110000000000
10198                                                                              10987654321098765432109876543210
10199                                                                              000001x1xx1x1000001110xxxxxxxxxx
10200                                                                              rev.  */
10201                                                                           return 1806;
10202                                                                         }
10203                                                                     }
10204                                                                   else
10205                                                                     {
10206                                                                       if (((word >> 20) & 0x1) == 0)
10207                                                                         {
10208                                                                           /* 33222222222211111111110000000000
10209                                                                              10987654321098765432109876543210
10210                                                                              000001x1xx10x100001110xxxxxxxxxx
10211                                                                              insr.  */
10212                                                                           return 1498;
10213                                                                         }
10214                                                                       else
10215                                                                         {
10216                                                                           /* 33222222222211111111110000000000
10217                                                                              10987654321098765432109876543210
10218                                                                              000001x1xx11x100001110xxxxxxxxxx
10219                                                                              insr.  */
10220                                                                           return 1499;
10221                                                                         }
10222                                                                     }
10223                                                                 }
10224                                                               else
10225                                                                 {
10226                                                                   /* 33222222222211111111110000000000
10227                                                                      10987654321098765432109876543210
10228                                                                      000001x1xx1xxx10001110xxxxxxxxxx
10229                                                                      uunpklo.  */
10230                                                                   return 2016;
10231                                                                 }
10232                                                             }
10233                                                           else
10234                                                             {
10235                                                               if (((word >> 17) & 0x1) == 0)
10236                                                                 {
10237                                                                   /* 33222222222211111111110000000000
10238                                                                      10987654321098765432109876543210
10239                                                                      000001x1xx1xxx01001110xxxxxxxxxx
10240                                                                      sunpkhi.  */
10241                                                                   return 1952;
10242                                                                 }
10243                                                               else
10244                                                                 {
10245                                                                   /* 33222222222211111111110000000000
10246                                                                      10987654321098765432109876543210
10247                                                                      000001x1xx1xxx11001110xxxxxxxxxx
10248                                                                      uunpkhi.  */
10249                                                                   return 2015;
10250                                                                 }
10251                                                             }
10252                                                         }
10253                                                     }
10254                                                 }
10255                                               else
10256                                                 {
10257                                                   /* 33222222222211111111110000000000
10258                                                      10987654321098765432109876543210
10259                                                      000001x1xx1xxxxx001xx1xxxxxxxxxx
10260                                                      tbx.  */
10261                                                   return 2254;
10262                                                 }
10263                                             }
10264                                           else
10265                                             {
10266                                               if (((word >> 16) & 0x1) == 0)
10267                                                 {
10268                                                   if (((word >> 19) & 0x1) == 0)
10269                                                     {
10270                                                       if (((word >> 20) & 0x1) == 0)
10271                                                         {
10272                                                           /* 33222222222211111111110000000000
10273                                                              10987654321098765432109876543210
10274                                                              000001x1xx100xx0101xxxxxxxxxxxxx
10275                                                              lasta.  */
10276                                                           return 1500;
10277                                                         }
10278                                                       else
10279                                                         {
10280                                                           /* 33222222222211111111110000000000
10281                                                              10987654321098765432109876543210
10282                                                              000001x1xx110xx0101xxxxxxxxxxxxx
10283                                                              clasta.  */
10284                                                           return 1315;
10285                                                         }
10286                                                     }
10287                                                   else
10288                                                     {
10289                                                       /* 33222222222211111111110000000000
10290                                                          10987654321098765432109876543210
10291                                                          000001x1xx1x1xx0101xxxxxxxxxxxxx
10292                                                          cpy.  */
10293                                                       return 1356;
10294                                                     }
10295                                                 }
10296                                               else
10297                                                 {
10298                                                   if (((word >> 20) & 0x1) == 0)
10299                                                     {
10300                                                       /* 33222222222211111111110000000000
10301                                                          10987654321098765432109876543210
10302                                                          000001x1xx10xxx1101xxxxxxxxxxxxx
10303                                                          lastb.  */
10304                                                       return 1502;
10305                                                     }
10306                                                   else
10307                                                     {
10308                                                       /* 33222222222211111111110000000000
10309                                                          10987654321098765432109876543210
10310                                                          000001x1xx11xxx1101xxxxxxxxxxxxx
10311                                                          clastb.  */
10312                                                       return 1318;
10313                                                     }
10314                                                 }
10315                                             }
10316                                         }
10317                                     }
10318                                   else
10319                                     {
10320                                       if (((word >> 15) & 0x1) == 0)
10321                                         {
10322                                           if (((word >> 10) & 0x1) == 0)
10323                                             {
10324                                               if (((word >> 11) & 0x1) == 0)
10325                                                 {
10326                                                   if (((word >> 12) & 0x1) == 0)
10327                                                     {
10328                                                       if (((word >> 13) & 0x1) == 0)
10329                                                         {
10330                                                           if (((word >> 20) & 0x1) == 0)
10331                                                             {
10332                                                               /* 33222222222211111111110000000000
10333                                                                  10987654321098765432109876543210
10334                                                                  000001x1xx10xxxx010000xxxxxxxxxx
10335                                                                  zip1.  */
10336                                                               return 2033;
10337                                                             }
10338                                                           else
10339                                                             {
10340                                                               if (((word >> 16) & 0x1) == 0)
10341                                                                 {
10342                                                                   if (((word >> 18) & 0x1) == 0)
10343                                                                     {
10344                                                                       /* 33222222222211111111110000000000
10345                                                                          10987654321098765432109876543210
10346                                                                          000001x1xx11x0x0010000xxxxxxxxxx
10347                                                                          punpklo.  */
10348                                                                       return 1799;
10349                                                                     }
10350                                                                   else
10351                                                                     {
10352                                                                       /* 33222222222211111111110000000000
10353                                                                          10987654321098765432109876543210
10354                                                                          000001x1xx11x1x0010000xxxxxxxxxx
10355                                                                          rev.  */
10356                                                                       return 1805;
10357                                                                     }
10358                                                                 }
10359                                                               else
10360                                                                 {
10361                                                                   /* 33222222222211111111110000000000
10362                                                                      10987654321098765432109876543210
10363                                                                      000001x1xx11xxx1010000xxxxxxxxxx
10364                                                                      punpkhi.  */
10365                                                                   return 1798;
10366                                                                 }
10367                                                             }
10368                                                         }
10369                                                       else
10370                                                         {
10371                                                           /* 33222222222211111111110000000000
10372                                                              10987654321098765432109876543210
10373                                                              000001x1xx1xxxxx011000xxxxxxxxxx
10374                                                              zip1.  */
10375                                                           return 2034;
10376                                                         }
10377                                                     }
10378                                                   else
10379                                                     {
10380                                                       if (((word >> 13) & 0x1) == 0)
10381                                                         {
10382                                                           /* 33222222222211111111110000000000
10383                                                              10987654321098765432109876543210
10384                                                              000001x1xx1xxxxx010100xxxxxxxxxx
10385                                                              trn1.  */
10386                                                           return 1958;
10387                                                         }
10388                                                       else
10389                                                         {
10390                                                           /* 33222222222211111111110000000000
10391                                                              10987654321098765432109876543210
10392                                                              000001x1xx1xxxxx011100xxxxxxxxxx
10393                                                              trn1.  */
10394                                                           return 1959;
10395                                                         }
10396                                                     }
10397                                                 }
10398                                               else
10399                                                 {
10400                                                   if (((word >> 13) & 0x1) == 0)
10401                                                     {
10402                                                       /* 33222222222211111111110000000000
10403                                                          10987654321098765432109876543210
10404                                                          000001x1xx1xxxxx010x10xxxxxxxxxx
10405                                                          uzp1.  */
10406                                                       return 2020;
10407                                                     }
10408                                                   else
10409                                                     {
10410                                                       /* 33222222222211111111110000000000
10411                                                          10987654321098765432109876543210
10412                                                          000001x1xx1xxxxx011x10xxxxxxxxxx
10413                                                          uzp1.  */
10414                                                       return 2021;
10415                                                     }
10416                                                 }
10417                                             }
10418                                           else
10419                                             {
10420                                               if (((word >> 11) & 0x1) == 0)
10421                                                 {
10422                                                   if (((word >> 12) & 0x1) == 0)
10423                                                     {
10424                                                       if (((word >> 13) & 0x1) == 0)
10425                                                         {
10426                                                           /* 33222222222211111111110000000000
10427                                                              10987654321098765432109876543210
10428                                                              000001x1xx1xxxxx010001xxxxxxxxxx
10429                                                              zip2.  */
10430                                                           return 2035;
10431                                                         }
10432                                                       else
10433                                                         {
10434                                                           /* 33222222222211111111110000000000
10435                                                              10987654321098765432109876543210
10436                                                              000001x1xx1xxxxx011001xxxxxxxxxx
10437                                                              zip2.  */
10438                                                           return 2036;
10439                                                         }
10440                                                     }
10441                                                   else
10442                                                     {
10443                                                       if (((word >> 13) & 0x1) == 0)
10444                                                         {
10445                                                           /* 33222222222211111111110000000000
10446                                                              10987654321098765432109876543210
10447                                                              000001x1xx1xxxxx010101xxxxxxxxxx
10448                                                              trn2.  */
10449                                                           return 1960;
10450                                                         }
10451                                                       else
10452                                                         {
10453                                                           /* 33222222222211111111110000000000
10454                                                              10987654321098765432109876543210
10455                                                              000001x1xx1xxxxx011101xxxxxxxxxx
10456                                                              trn2.  */
10457                                                           return 1961;
10458                                                         }
10459                                                     }
10460                                                 }
10461                                               else
10462                                                 {
10463                                                   if (((word >> 13) & 0x1) == 0)
10464                                                     {
10465                                                       /* 33222222222211111111110000000000
10466                                                          10987654321098765432109876543210
10467                                                          000001x1xx1xxxxx010x11xxxxxxxxxx
10468                                                          uzp2.  */
10469                                                       return 2022;
10470                                                     }
10471                                                   else
10472                                                     {
10473                                                       /* 33222222222211111111110000000000
10474                                                          10987654321098765432109876543210
10475                                                          000001x1xx1xxxxx011x11xxxxxxxxxx
10476                                                          uzp2.  */
10477                                                       return 2023;
10478                                                     }
10479                                                 }
10480                                             }
10481                                         }
10482                                       else
10483                                         {
10484                                           /* 33222222222211111111110000000000
10485                                              10987654321098765432109876543210
10486                                              000001x1xx1xxxxx11xxxxxxxxxxxxxx
10487                                              sel.  */
10488                                           return 1824;
10489                                         }
10490                                     }
10491                                 }
10492                             }
10493                           else
10494                             {
10495                               if (((word >> 13) & 0x1) == 0)
10496                                 {
10497                                   if (((word >> 14) & 0x1) == 0)
10498                                     {
10499                                       if (((word >> 15) & 0x1) == 0)
10500                                         {
10501                                           if (((word >> 22) & 0x1) == 0)
10502                                             {
10503                                               /* 33222222222211111111110000000000
10504                                                  10987654321098765432109876543210
10505                                                  100001x1x0xxxxxx000xxxxxxxxxxxxx
10506                                                  ldr.  */
10507                                               return 1728;
10508                                             }
10509                                           else
10510                                             {
10511                                               /* 33222222222211111111110000000000
10512                                                  10987654321098765432109876543210
10513                                                  100001x1x1xxxxxx000xxxxxxxxxxxxx
10514                                                  prfb.  */
10515                                               return 1772;
10516                                             }
10517                                         }
10518                                       else
10519                                         {
10520                                           if (((word >> 23) & 0x1) == 0)
10521                                             {
10522                                               /* 33222222222211111111110000000000
10523                                                  10987654321098765432109876543210
10524                                                  100001x10xxxxxxx100xxxxxxxxxxxxx
10525                                                  ld1rsh.  */
10526                                               return 1557;
10527                                             }
10528                                           else
10529                                             {
10530                                               /* 33222222222211111111110000000000
10531                                                  10987654321098765432109876543210
10532                                                  100001x11xxxxxxx100xxxxxxxxxxxxx
10533                                                  ld1rsb.  */
10534                                               return 1554;
10535                                             }
10536                                         }
10537                                     }
10538                                   else
10539                                     {
10540                                       if (((word >> 15) & 0x1) == 0)
10541                                         {
10542                                           if (((word >> 23) & 0x1) == 0)
10543                                             {
10544                                               if (((word >> 21) & 0x1) == 0)
10545                                                 {
10546                                                   /* 33222222222211111111110000000000
10547                                                      10987654321098765432109876543210
10548                                                      100001x10x0xxxxx010xxxxxxxxxxxxx
10549                                                      ld1w.  */
10550                                                   return 1592;
10551                                                 }
10552                                               else
10553                                                 {
10554                                                   /* 33222222222211111111110000000000
10555                                                      10987654321098765432109876543210
10556                                                      100001x10x1xxxxx010xxxxxxxxxxxxx
10557                                                      ld1w.  */
10558                                                   return 1593;
10559                                                 }
10560                                             }
10561                                           else
10562                                             {
10563                                               if (((word >> 22) & 0x1) == 0)
10564                                                 {
10565                                                   /* 33222222222211111111110000000000
10566                                                      10987654321098765432109876543210
10567                                                      100001x110xxxxxx010xxxxxxxxxxxxx
10568                                                      ldr.  */
10569                                                   return 1729;
10570                                                 }
10571                                               else
10572                                                 {
10573                                                   /* 33222222222211111111110000000000
10574                                                      10987654321098765432109876543210
10575                                                      100001x111xxxxxx010xxxxxxxxxxxxx
10576                                                      prfw.  */
10577                                                   return 1793;
10578                                                 }
10579                                             }
10580                                         }
10581                                       else
10582                                         {
10583                                           if (((word >> 22) & 0x1) == 0)
10584                                             {
10585                                               if (((word >> 21) & 0x1) == 0)
10586                                                 {
10587                                                   if (((word >> 23) & 0x1) == 0)
10588                                                     {
10589                                                       /* 33222222222211111111110000000000
10590                                                          10987654321098765432109876543210
10591                                                          100001x1000xxxxx110xxxxxxxxxxxxx
10592                                                          prfw.  */
10593                                                       return 1789;
10594                                                     }
10595                                                   else
10596                                                     {
10597                                                       /* 33222222222211111111110000000000
10598                                                          10987654321098765432109876543210
10599                                                          100001x1100xxxxx110xxxxxxxxxxxxx
10600                                                          prfd.  */
10601                                                       return 1775;
10602                                                     }
10603                                                 }
10604                                               else
10605                                                 {
10606                                                   /* 33222222222211111111110000000000
10607                                                      10987654321098765432109876543210
10608                                                      100001x1x01xxxxx110xxxxxxxxxxxxx
10609                                                      ld1w.  */
10610                                                   return 1600;
10611                                                 }
10612                                             }
10613                                           else
10614                                             {
10615                                               if (((word >> 23) & 0x1) == 0)
10616                                                 {
10617                                                   /* 33222222222211111111110000000000
10618                                                      10987654321098765432109876543210
10619                                                      100001x101xxxxxx110xxxxxxxxxxxxx
10620                                                      ld1rw.  */
10621                                                   return 1560;
10622                                                 }
10623                                               else
10624                                                 {
10625                                                   /* 33222222222211111111110000000000
10626                                                      10987654321098765432109876543210
10627                                                      100001x111xxxxxx110xxxxxxxxxxxxx
10628                                                      ld1rsb.  */
10629                                                   return 1556;
10630                                                 }
10631                                             }
10632                                         }
10633                                     }
10634                                 }
10635                               else
10636                                 {
10637                                   if (((word >> 14) & 0x1) == 0)
10638                                     {
10639                                       if (((word >> 15) & 0x1) == 0)
10640                                         {
10641                                           /* 33222222222211111111110000000000
10642                                              10987654321098765432109876543210
10643                                              100001x1xxxxxxxx001xxxxxxxxxxxxx
10644                                              prfh.  */
10645                                           return 1786;
10646                                         }
10647                                       else
10648                                         {
10649                                           if (((word >> 22) & 0x1) == 0)
10650                                             {
10651                                               /* 33222222222211111111110000000000
10652                                                  10987654321098765432109876543210
10653                                                  100001x1x0xxxxxx101xxxxxxxxxxxxx
10654                                                  ldnt1w.  */
10655                                               return 2100;
10656                                             }
10657                                           else
10658                                             {
10659                                               if (((word >> 23) & 0x1) == 0)
10660                                                 {
10661                                                   /* 33222222222211111111110000000000
10662                                                      10987654321098765432109876543210
10663                                                      100001x101xxxxxx101xxxxxxxxxxxxx
10664                                                      ld1rsh.  */
10665                                                   return 1558;
10666                                                 }
10667                                               else
10668                                                 {
10669                                                   /* 33222222222211111111110000000000
10670                                                      10987654321098765432109876543210
10671                                                      100001x111xxxxxx101xxxxxxxxxxxxx
10672                                                      ld1rsb.  */
10673                                                   return 1555;
10674                                                 }
10675                                             }
10676                                         }
10677                                     }
10678                                   else
10679                                     {
10680                                       if (((word >> 15) & 0x1) == 0)
10681                                         {
10682                                           if (((word >> 23) & 0x1) == 0)
10683                                             {
10684                                               if (((word >> 21) & 0x1) == 0)
10685                                                 {
10686                                                   /* 33222222222211111111110000000000
10687                                                      10987654321098765432109876543210
10688                                                      100001x10x0xxxxx011xxxxxxxxxxxxx
10689                                                      ldff1w.  */
10690                                                   return 1692;
10691                                                 }
10692                                               else
10693                                                 {
10694                                                   /* 33222222222211111111110000000000
10695                                                      10987654321098765432109876543210
10696                                                      100001x10x1xxxxx011xxxxxxxxxxxxx
10697                                                      ldff1w.  */
10698                                                   return 1693;
10699                                                 }
10700                                             }
10701                                           else
10702                                             {
10703                                               /* 33222222222211111111110000000000
10704                                                  10987654321098765432109876543210
10705                                                  100001x11xxxxxxx011xxxxxxxxxxxxx
10706                                                  prfd.  */
10707                                               return 1779;
10708                                             }
10709                                         }
10710                                       else
10711                                         {
10712                                           if (((word >> 22) & 0x1) == 0)
10713                                             {
10714                                               if (((word >> 21) & 0x1) == 0)
10715                                                 {
10716                                                   if (((word >> 23) & 0x1) == 0)
10717                                                     {
10718                                                       /* 33222222222211111111110000000000
10719                                                          10987654321098765432109876543210
10720                                                          100001x1000xxxxx111xxxxxxxxxxxxx
10721                                                          prfw.  */
10722                                                       return 1792;
10723                                                     }
10724                                                   else
10725                                                     {
10726                                                       /* 33222222222211111111110000000000
10727                                                          10987654321098765432109876543210
10728                                                          100001x1100xxxxx111xxxxxxxxxxxxx
10729                                                          prfd.  */
10730                                                       return 1778;
10731                                                     }
10732                                                 }
10733                                               else
10734                                                 {
10735                                                   /* 33222222222211111111110000000000
10736                                                      10987654321098765432109876543210
10737                                                      100001x1x01xxxxx111xxxxxxxxxxxxx
10738                                                      ldff1w.  */
10739                                                   return 1702;
10740                                                 }
10741                                             }
10742                                           else
10743                                             {
10744                                               if (((word >> 23) & 0x1) == 0)
10745                                                 {
10746                                                   /* 33222222222211111111110000000000
10747                                                      10987654321098765432109876543210
10748                                                      100001x101xxxxxx111xxxxxxxxxxxxx
10749                                                      ld1rw.  */
10750                                                   return 1561;
10751                                                 }
10752                                               else
10753                                                 {
10754                                                   /* 33222222222211111111110000000000
10755                                                      10987654321098765432109876543210
10756                                                      100001x111xxxxxx111xxxxxxxxxxxxx
10757                                                      ld1rd.  */
10758                                                   return 1542;
10759                                                 }
10760                                             }
10761                                         }
10762                                     }
10763                                 }
10764                             }
10765                         }
10766                       else
10767                         {
10768                           if (((word >> 13) & 0x1) == 0)
10769                             {
10770                               if (((word >> 14) & 0x1) == 0)
10771                                 {
10772                                   if (((word >> 15) & 0x1) == 0)
10773                                     {
10774                                       if (((word >> 21) & 0x1) == 0)
10775                                         {
10776                                           if (((word >> 31) & 0x1) == 0)
10777                                             {
10778                                               if (((word >> 10) & 0x1) == 0)
10779                                                 {
10780                                                   if (((word >> 11) & 0x1) == 0)
10781                                                     {
10782                                                       if (((word >> 12) & 0x1) == 0)
10783                                                         {
10784                                                           /* 33222222222211111111110000000000
10785                                                              10987654321098765432109876543210
10786                                                              010001x1xx0xxxxx000000xxxxxxxxxx
10787                                                              saddlb.  */
10788                                                           return 2130;
10789                                                         }
10790                                                       else
10791                                                         {
10792                                                           /* 33222222222211111111110000000000
10793                                                              10987654321098765432109876543210
10794                                                              010001x1xx0xxxxx000100xxxxxxxxxx
10795                                                              ssublb.  */
10796                                                           return 2237;
10797                                                         }
10798                                                     }
10799                                                   else
10800                                                     {
10801                                                       if (((word >> 12) & 0x1) == 0)
10802                                                         {
10803                                                           /* 33222222222211111111110000000000
10804                                                              10987654321098765432109876543210
10805                                                              010001x1xx0xxxxx000010xxxxxxxxxx
10806                                                              uaddlb.  */
10807                                                           return 2261;
10808                                                         }
10809                                                       else
10810                                                         {
10811                                                           /* 33222222222211111111110000000000
10812                                                              10987654321098765432109876543210
10813                                                              010001x1xx0xxxxx000110xxxxxxxxxx
10814                                                              usublb.  */
10815                                                           return 2314;
10816                                                         }
10817                                                     }
10818                                                 }
10819                                               else
10820                                                 {
10821                                                   if (((word >> 11) & 0x1) == 0)
10822                                                     {
10823                                                       if (((word >> 12) & 0x1) == 0)
10824                                                         {
10825                                                           /* 33222222222211111111110000000000
10826                                                              10987654321098765432109876543210
10827                                                              010001x1xx0xxxxx000001xxxxxxxxxx
10828                                                              saddlt.  */
10829                                                           return 2132;
10830                                                         }
10831                                                       else
10832                                                         {
10833                                                           /* 33222222222211111111110000000000
10834                                                              10987654321098765432109876543210
10835                                                              010001x1xx0xxxxx000101xxxxxxxxxx
10836                                                              ssublt.  */
10837                                                           return 2239;
10838                                                         }
10839                                                     }
10840                                                   else
10841                                                     {
10842                                                       if (((word >> 12) & 0x1) == 0)
10843                                                         {
10844                                                           /* 33222222222211111111110000000000
10845                                                              10987654321098765432109876543210
10846                                                              010001x1xx0xxxxx000011xxxxxxxxxx
10847                                                              uaddlt.  */
10848                                                           return 2262;
10849                                                         }
10850                                                       else
10851                                                         {
10852                                                           /* 33222222222211111111110000000000
10853                                                              10987654321098765432109876543210
10854                                                              010001x1xx0xxxxx000111xxxxxxxxxx
10855                                                              usublt.  */
10856                                                           return 2315;
10857                                                         }
10858                                                     }
10859                                                 }
10860                                             }
10861                                           else
10862                                             {
10863                                               /* 33222222222211111111110000000000
10864                                                  10987654321098765432109876543210
10865                                                  110001x1xx0xxxxx000xxxxxxxxxxxxx
10866                                                  ld1sw.  */
10867                                               return 1586;
10868                                             }
10869                                         }
10870                                       else
10871                                         {
10872                                           if (((word >> 31) & 0x1) == 0)
10873                                             {
10874                                               if (((word >> 10) & 0x1) == 0)
10875                                                 {
10876                                                   if (((word >> 11) & 0x1) == 0)
10877                                                     {
10878                                                       if (((word >> 12) & 0x1) == 0)
10879                                                         {
10880                                                           /* 33222222222211111111110000000000
10881                                                              10987654321098765432109876543210
10882                                                              010001x1xx1xxxxx000000xxxxxxxxxx
10883                                                              sqshrunb.  */
10884                                                           return 2220;
10885                                                         }
10886                                                       else
10887                                                         {
10888                                                           /* 33222222222211111111110000000000
10889                                                              10987654321098765432109876543210
10890                                                              010001x1xx1xxxxx000100xxxxxxxxxx
10891                                                              shrnb.  */
10892                                                           return 2138;
10893                                                         }
10894                                                     }
10895                                                   else
10896                                                     {
10897                                                       if (((word >> 12) & 0x1) == 0)
10898                                                         {
10899                                                           /* 33222222222211111111110000000000
10900                                                              10987654321098765432109876543210
10901                                                              010001x1xx1xxxxx000010xxxxxxxxxx
10902                                                              sqrshrunb.  */
10903                                                           return 2212;
10904                                                         }
10905                                                       else
10906                                                         {
10907                                                           /* 33222222222211111111110000000000
10908                                                              10987654321098765432109876543210
10909                                                              010001x1xx1xxxxx000110xxxxxxxxxx
10910                                                              rshrnb.  */
10911                                                           return 2120;
10912                                                         }
10913                                                     }
10914                                                 }
10915                                               else
10916                                                 {
10917                                                   if (((word >> 11) & 0x1) == 0)
10918                                                     {
10919                                                       if (((word >> 12) & 0x1) == 0)
10920                                                         {
10921                                                           /* 33222222222211111111110000000000
10922                                                              10987654321098765432109876543210
10923                                                              010001x1xx1xxxxx000001xxxxxxxxxx
10924                                                              sqshrunt.  */
10925                                                           return 2221;
10926                                                         }
10927                                                       else
10928                                                         {
10929                                                           /* 33222222222211111111110000000000
10930                                                              10987654321098765432109876543210
10931                                                              010001x1xx1xxxxx000101xxxxxxxxxx
10932                                                              shrnt.  */
10933                                                           return 2139;
10934                                                         }
10935                                                     }
10936                                                   else
10937                                                     {
10938                                                       if (((word >> 12) & 0x1) == 0)
10939                                                         {
10940                                                           /* 33222222222211111111110000000000
10941                                                              10987654321098765432109876543210
10942                                                              010001x1xx1xxxxx000011xxxxxxxxxx
10943                                                              sqrshrunt.  */
10944                                                           return 2213;
10945                                                         }
10946                                                       else
10947                                                         {
10948                                                           /* 33222222222211111111110000000000
10949                                                              10987654321098765432109876543210
10950                                                              010001x1xx1xxxxx000111xxxxxxxxxx
10951                                                              rshrnt.  */
10952                                                           return 2121;
10953                                                         }
10954                                                     }
10955                                                 }
10956                                             }
10957                                           else
10958                                             {
10959                                               /* 33222222222211111111110000000000
10960                                                  10987654321098765432109876543210
10961                                                  110001x1xx1xxxxx000xxxxxxxxxxxxx
10962                                                  ld1sw.  */
10963                                               return 1587;
10964                                             }
10965                                         }
10966                                     }
10967                                   else
10968                                     {
10969                                       if (((word >> 21) & 0x1) == 0)
10970                                         {
10971                                           if (((word >> 31) & 0x1) == 0)
10972                                             {
10973                                               if (((word >> 10) & 0x1) == 0)
10974                                                 {
10975                                                   if (((word >> 11) & 0x1) == 0)
10976                                                     {
10977                                                       if (((word >> 12) & 0x1) == 0)
10978                                                         {
10979                                                           /* 33222222222211111111110000000000
10980                                                              10987654321098765432109876543210
10981                                                              010001x1xx0xxxxx100000xxxxxxxxxx
10982                                                              saddlbt.  */
10983                                                           return 2131;
10984                                                         }
10985                                                       else
10986                                                         {
10987                                                           /* 33222222222211111111110000000000
10988                                                              10987654321098765432109876543210
10989                                                              010001x1xx0xxxxx100100xxxxxxxxxx
10990                                                              eorbt.  */
10991                                                           return 2067;
10992                                                         }
10993                                                     }
10994                                                   else
10995                                                     {
10996                                                       if (((word >> 12) & 0x1) == 0)
10997                                                         {
10998                                                           /* 33222222222211111111110000000000
10999                                                              10987654321098765432109876543210
11000                                                              010001x1xx0xxxxx100010xxxxxxxxxx
11001                                                              ssublbt.  */
11002                                                           return 2238;
11003                                                         }
11004                                                       else
11005                                                         {
11006                                                           if (((word >> 22) & 0x1) == 0)
11007                                                             {
11008                                                               if (((word >> 23) & 0x1) == 0)
11009                                                                 {
11010                                                                   /* 33222222222211111111110000000000
11011                                                                      10987654321098765432109876543210
11012                                                                      010001x1000xxxxx100110xxxxxxxxxx
11013                                                                      smmla.  */
11014                                                                   return 2394;
11015                                                                 }
11016                                                               else
11017                                                                 {
11018                                                                   /* 33222222222211111111110000000000
11019                                                                      10987654321098765432109876543210
11020                                                                      010001x1100xxxxx100110xxxxxxxxxx
11021                                                                      usmmla.  */
11022                                                                   return 2396;
11023                                                                 }
11024                                                             }
11025                                                           else
11026                                                             {
11027                                                               /* 33222222222211111111110000000000
11028                                                                  10987654321098765432109876543210
11029                                                                  010001x1x10xxxxx100110xxxxxxxxxx
11030                                                                  ummla.  */
11031                                                               return 2395;
11032                                                             }
11033                                                         }
11034                                                     }
11035                                                 }
11036                                               else
11037                                                 {
11038                                                   if (((word >> 11) & 0x1) == 0)
11039                                                     {
11040                                                       /* 33222222222211111111110000000000
11041                                                          10987654321098765432109876543210
11042                                                          010001x1xx0xxxxx100x01xxxxxxxxxx
11043                                                          eortb.  */
11044                                                       return 2068;
11045                                                     }
11046                                                   else
11047                                                     {
11048                                                       /* 33222222222211111111110000000000
11049                                                          10987654321098765432109876543210
11050                                                          010001x1xx0xxxxx100x11xxxxxxxxxx
11051                                                          ssubltb.  */
11052                                                       return 2240;
11053                                                     }
11054                                                 }
11055                                             }
11056                                           else
11057                                             {
11058                                               if (((word >> 22) & 0x1) == 0)
11059                                                 {
11060                                                   /* 33222222222211111111110000000000
11061                                                      10987654321098765432109876543210
11062                                                      110001x1x00xxxxx100xxxxxxxxxxxxx
11063                                                      ldnt1sw.  */
11064                                                   return 2099;
11065                                                 }
11066                                               else
11067                                                 {
11068                                                   /* 33222222222211111111110000000000
11069                                                      10987654321098765432109876543210
11070                                                      110001x1x10xxxxx100xxxxxxxxxxxxx
11071                                                      ld1sw.  */
11072                                                   return 1588;
11073                                                 }
11074                                             }
11075                                         }
11076                                       else
11077                                         {
11078                                           if (((word >> 31) & 0x1) == 0)
11079                                             {
11080                                               if (((word >> 4) & 0x1) == 0)
11081                                                 {
11082                                                   /* 33222222222211111111110000000000
11083                                                      10987654321098765432109876543210
11084                                                      010001x1xx1xxxxx100xxxxxxxx0xxxx
11085                                                      match.  */
11086                                                   return 2102;
11087                                                 }
11088                                               else
11089                                                 {
11090                                                   /* 33222222222211111111110000000000
11091                                                      10987654321098765432109876543210
11092                                                      010001x1xx1xxxxx100xxxxxxxx1xxxx
11093                                                      nmatch.  */
11094                                                   return 2114;
11095                                                 }
11096                                             }
11097                                           else
11098                                             {
11099                                               if (((word >> 22) & 0x1) == 0)
11100                                                 {
11101                                                   /* 33222222222211111111110000000000
11102                                                      10987654321098765432109876543210
11103                                                      110001x1x01xxxxx100xxxxxxxxxxxxx
11104                                                      ld1sw.  */
11105                                                   return 1591;
11106                                                 }
11107                                               else
11108                                                 {
11109                                                   /* 33222222222211111111110000000000
11110                                                      10987654321098765432109876543210
11111                                                      110001x1x11xxxxx100xxxxxxxxxxxxx
11112                                                      ld1sw.  */
11113                                                   return 1589;
11114                                                 }
11115                                             }
11116                                         }
11117                                     }
11118                                 }
11119                               else
11120                                 {
11121                                   if (((word >> 15) & 0x1) == 0)
11122                                     {
11123                                       if (((word >> 21) & 0x1) == 0)
11124                                         {
11125                                           if (((word >> 31) & 0x1) == 0)
11126                                             {
11127                                               if (((word >> 10) & 0x1) == 0)
11128                                                 {
11129                                                   if (((word >> 11) & 0x1) == 0)
11130                                                     {
11131                                                       if (((word >> 12) & 0x1) == 0)
11132                                                         {
11133                                                           /* 33222222222211111111110000000000
11134                                                              10987654321098765432109876543210
11135                                                              010001x1xx0xxxxx010000xxxxxxxxxx
11136                                                              saddwb.  */
11137                                                           return 2133;
11138                                                         }
11139                                                       else
11140                                                         {
11141                                                           /* 33222222222211111111110000000000
11142                                                              10987654321098765432109876543210
11143                                                              010001x1xx0xxxxx010100xxxxxxxxxx
11144                                                              ssubwb.  */
11145                                                           return 2241;
11146                                                         }
11147                                                     }
11148                                                   else
11149                                                     {
11150                                                       if (((word >> 12) & 0x1) == 0)
11151                                                         {
11152                                                           /* 33222222222211111111110000000000
11153                                                              10987654321098765432109876543210
11154                                                              010001x1xx0xxxxx010010xxxxxxxxxx
11155                                                              uaddwb.  */
11156                                                           return 2263;
11157                                                         }
11158                                                       else
11159                                                         {
11160                                                           /* 33222222222211111111110000000000
11161                                                              10987654321098765432109876543210
11162                                                              010001x1xx0xxxxx010110xxxxxxxxxx
11163                                                              usubwb.  */
11164                                                           return 2316;
11165                                                         }
11166                                                     }
11167                                                 }
11168                                               else
11169                                                 {
11170                                                   if (((word >> 11) & 0x1) == 0)
11171                                                     {
11172                                                       if (((word >> 12) & 0x1) == 0)
11173                                                         {
11174                                                           /* 33222222222211111111110000000000
11175                                                              10987654321098765432109876543210
11176                                                              010001x1xx0xxxxx010001xxxxxxxxxx
11177                                                              saddwt.  */
11178                                                           return 2134;
11179                                                         }
11180                                                       else
11181                                                         {
11182                                                           /* 33222222222211111111110000000000
11183                                                              10987654321098765432109876543210
11184                                                              010001x1xx0xxxxx010101xxxxxxxxxx
11185                                                              ssubwt.  */
11186                                                           return 2242;
11187                                                         }
11188                                                     }
11189                                                   else
11190                                                     {
11191                                                       if (((word >> 12) & 0x1) == 0)
11192                                                         {
11193                                                           /* 33222222222211111111110000000000
11194                                                              10987654321098765432109876543210
11195                                                              010001x1xx0xxxxx010011xxxxxxxxxx
11196                                                              uaddwt.  */
11197                                                           return 2264;
11198                                                         }
11199                                                       else
11200                                                         {
11201                                                           /* 33222222222211111111110000000000
11202                                                              10987654321098765432109876543210
11203                                                              010001x1xx0xxxxx010111xxxxxxxxxx
11204                                                              usubwt.  */
11205                                                           return 2317;
11206                                                         }
11207                                                     }
11208                                                 }
11209                                             }
11210                                           else
11211                                             {
11212                                               if (((word >> 23) & 0x1) == 0)
11213                                                 {
11214                                                   /* 33222222222211111111110000000000
11215                                                      10987654321098765432109876543210
11216                                                      110001x10x0xxxxx010xxxxxxxxxxxxx
11217                                                      ld1w.  */
11218                                                   return 1596;
11219                                                 }
11220                                               else
11221                                                 {
11222                                                   /* 33222222222211111111110000000000
11223                                                      10987654321098765432109876543210
11224                                                      110001x11x0xxxxx010xxxxxxxxxxxxx
11225                                                      ld1d.  */
11226                                                   return 1518;
11227                                                 }
11228                                             }
11229                                         }
11230                                       else
11231                                         {
11232                                           if (((word >> 23) & 0x1) == 0)
11233                                             {
11234                                               if (((word >> 31) & 0x1) == 0)
11235                                                 {
11236                                                   if (((word >> 10) & 0x1) == 0)
11237                                                     {
11238                                                       if (((word >> 11) & 0x1) == 0)
11239                                                         {
11240                                                           if (((word >> 12) & 0x1) == 0)
11241                                                             {
11242                                                               /* 33222222222211111111110000000000
11243                                                                  10987654321098765432109876543210
11244                                                                  010001x10x1xxxxx010000xxxxxxxxxx
11245                                                                  sqxtnb.  */
11246                                                               return 2224;
11247                                                             }
11248                                                           else
11249                                                             {
11250                                                               /* 33222222222211111111110000000000
11251                                                                  10987654321098765432109876543210
11252                                                                  010001x10x1xxxxx010100xxxxxxxxxx
11253                                                                  sqxtunb.  */
11254                                                               return 2226;
11255                                                             }
11256                                                         }
11257                                                       else
11258                                                         {
11259                                                           /* 33222222222211111111110000000000
11260                                                              10987654321098765432109876543210
11261                                                              010001x10x1xxxxx010x10xxxxxxxxxx
11262                                                              uqxtnb.  */
11263                                                           return 2301;
11264                                                         }
11265                                                     }
11266                                                   else
11267                                                     {
11268                                                       if (((word >> 11) & 0x1) == 0)
11269                                                         {
11270                                                           if (((word >> 12) & 0x1) == 0)
11271                                                             {
11272                                                               /* 33222222222211111111110000000000
11273                                                                  10987654321098765432109876543210
11274                                                                  010001x10x1xxxxx010001xxxxxxxxxx
11275                                                                  sqxtnt.  */
11276                                                               return 2225;
11277                                                             }
11278                                                           else
11279                                                             {
11280                                                               /* 33222222222211111111110000000000
11281                                                                  10987654321098765432109876543210
11282                                                                  010001x10x1xxxxx010101xxxxxxxxxx
11283                                                                  sqxtunt.  */
11284                                                               return 2227;
11285                                                             }
11286                                                         }
11287                                                       else
11288                                                         {
11289                                                           /* 33222222222211111111110000000000
11290                                                              10987654321098765432109876543210
11291                                                              010001x10x1xxxxx010x11xxxxxxxxxx
11292                                                              uqxtnt.  */
11293                                                           return 2302;
11294                                                         }
11295                                                     }
11296                                                 }
11297                                               else
11298                                                 {
11299                                                   /* 33222222222211111111110000000000
11300                                                      10987654321098765432109876543210
11301                                                      110001x10x1xxxxx010xxxxxxxxxxxxx
11302                                                      ld1w.  */
11303                                                   return 1597;
11304                                                 }
11305                                             }
11306                                           else
11307                                             {
11308                                               /* 33222222222211111111110000000000
11309                                                  10987654321098765432109876543210
11310                                                  x10001x11x1xxxxx010xxxxxxxxxxxxx
11311                                                  ld1d.  */
11312                                               return 1519;
11313                                             }
11314                                         }
11315                                     }
11316                                   else
11317                                     {
11318                                       if (((word >> 21) & 0x1) == 0)
11319                                         {
11320                                           if (((word >> 31) & 0x1) == 0)
11321                                             {
11322                                               if (((word >> 11) & 0x1) == 0)
11323                                                 {
11324                                                   if (((word >> 10) & 0x1) == 0)
11325                                                     {
11326                                                       if (((word >> 12) & 0x1) == 0)
11327                                                         {
11328                                                           /* 33222222222211111111110000000000
11329                                                              10987654321098765432109876543210
11330                                                              010001x1xx0xxxxx110000xxxxxxxxxx
11331                                                              sabalb.  */
11332                                                           return 2125;
11333                                                         }
11334                                                       else
11335                                                         {
11336                                                           if (((word >> 23) & 0x1) == 0)
11337                                                             {
11338                                                               /* 33222222222211111111110000000000
11339                                                                  10987654321098765432109876543210
11340                                                                  010001x10x0xxxxx110100xxxxxxxxxx
11341                                                                  adclb.  */
11342                                                               return 2050;
11343                                                             }
11344                                                           else
11345                                                             {
11346                                                               /* 33222222222211111111110000000000
11347                                                                  10987654321098765432109876543210
11348                                                                  010001x11x0xxxxx110100xxxxxxxxxx
11349                                                                  sbclb.  */
11350                                                               return 2135;
11351                                                             }
11352                                                         }
11353                                                     }
11354                                                   else
11355                                                     {
11356                                                       if (((word >> 12) & 0x1) == 0)
11357                                                         {
11358                                                           /* 33222222222211111111110000000000
11359                                                              10987654321098765432109876543210
11360                                                              010001x1xx0xxxxx110001xxxxxxxxxx
11361                                                              sabalt.  */
11362                                                           return 2126;
11363                                                         }
11364                                                       else
11365                                                         {
11366                                                           if (((word >> 23) & 0x1) == 0)
11367                                                             {
11368                                                               /* 33222222222211111111110000000000
11369                                                                  10987654321098765432109876543210
11370                                                                  010001x10x0xxxxx110101xxxxxxxxxx
11371                                                                  adclt.  */
11372                                                               return 2051;
11373                                                             }
11374                                                           else
11375                                                             {
11376                                                               /* 33222222222211111111110000000000
11377                                                                  10987654321098765432109876543210
11378                                                                  010001x11x0xxxxx110101xxxxxxxxxx
11379                                                                  sbclt.  */
11380                                                               return 2136;
11381                                                             }
11382                                                         }
11383                                                     }
11384                                                 }
11385                                               else
11386                                                 {
11387                                                   if (((word >> 12) & 0x1) == 0)
11388                                                     {
11389                                                       if (((word >> 10) & 0x1) == 0)
11390                                                         {
11391                                                           /* 33222222222211111111110000000000
11392                                                              10987654321098765432109876543210
11393                                                              010001x1xx0xxxxx110010xxxxxxxxxx
11394                                                              uabalb.  */
11395                                                           return 2256;
11396                                                         }
11397                                                       else
11398                                                         {
11399                                                           /* 33222222222211111111110000000000
11400                                                              10987654321098765432109876543210
11401                                                              010001x1xx0xxxxx110011xxxxxxxxxx
11402                                                              uabalt.  */
11403                                                           return 2257;
11404                                                         }
11405                                                     }
11406                                                   else
11407                                                     {
11408                                                       if (((word >> 16) & 0x1) == 0)
11409                                                         {
11410                                                           /* 33222222222211111111110000000000
11411                                                              10987654321098765432109876543210
11412                                                              010001x1xx0xxxx011011xxxxxxxxxxx
11413                                                              cadd.  */
11414                                                           return 2059;
11415                                                         }
11416                                                       else
11417                                                         {
11418                                                           /* 33222222222211111111110000000000
11419                                                              10987654321098765432109876543210
11420                                                              010001x1xx0xxxx111011xxxxxxxxxxx
11421                                                              sqcadd.  */
11422                                                           return 2167;
11423                                                         }
11424                                                     }
11425                                                 }
11426                                             }
11427                                           else
11428                                             {
11429                                               if (((word >> 22) & 0x1) == 0)
11430                                                 {
11431                                                   if (((word >> 23) & 0x1) == 0)
11432                                                     {
11433                                                       /* 33222222222211111111110000000000
11434                                                          10987654321098765432109876543210
11435                                                          110001x1000xxxxx110xxxxxxxxxxxxx
11436                                                          ldnt1w.  */
11437                                                       return 2101;
11438                                                     }
11439                                                   else
11440                                                     {
11441                                                       /* 33222222222211111111110000000000
11442                                                          10987654321098765432109876543210
11443                                                          110001x1100xxxxx110xxxxxxxxxxxxx
11444                                                          ldnt1d.  */
11445                                                       return 2094;
11446                                                     }
11447                                                 }
11448                                               else
11449                                                 {
11450                                                   if (((word >> 23) & 0x1) == 0)
11451                                                     {
11452                                                       /* 33222222222211111111110000000000
11453                                                          10987654321098765432109876543210
11454                                                          110001x1010xxxxx110xxxxxxxxxxxxx
11455                                                          ld1w.  */
11456                                                       return 1598;
11457                                                     }
11458                                                   else
11459                                                     {
11460                                                       /* 33222222222211111111110000000000
11461                                                          10987654321098765432109876543210
11462                                                          110001x1110xxxxx110xxxxxxxxxxxxx
11463                                                          ld1d.  */
11464                                                       return 1520;
11465                                                     }
11466                                                 }
11467                                             }
11468                                         }
11469                                       else
11470                                         {
11471                                           if (((word >> 23) & 0x1) == 0)
11472                                             {
11473                                               if (((word >> 22) & 0x1) == 0)
11474                                                 {
11475                                                   /* 33222222222211111111110000000000
11476                                                      10987654321098765432109876543210
11477                                                      x10001x1001xxxxx110xxxxxxxxxxxxx
11478                                                      ld1w.  */
11479                                                   return 1603;
11480                                                 }
11481                                               else
11482                                                 {
11483                                                   /* 33222222222211111111110000000000
11484                                                      10987654321098765432109876543210
11485                                                      x10001x1011xxxxx110xxxxxxxxxxxxx
11486                                                      ld1w.  */
11487                                                   return 1599;
11488                                                 }
11489                                             }
11490                                           else
11491                                             {
11492                                               if (((word >> 31) & 0x1) == 0)
11493                                                 {
11494                                                   /* 33222222222211111111110000000000
11495                                                      10987654321098765432109876543210
11496                                                      010001x11x1xxxxx110xxxxxxxxxxxxx
11497                                                      histcnt.  */
11498                                                   return 2090;
11499                                                 }
11500                                               else
11501                                                 {
11502                                                   if (((word >> 22) & 0x1) == 0)
11503                                                     {
11504                                                       /* 33222222222211111111110000000000
11505                                                          10987654321098765432109876543210
11506                                                          110001x1101xxxxx110xxxxxxxxxxxxx
11507                                                          ld1d.  */
11508                                                       return 1523;
11509                                                     }
11510                                                   else
11511                                                     {
11512                                                       /* 33222222222211111111110000000000
11513                                                          10987654321098765432109876543210
11514                                                          110001x1111xxxxx110xxxxxxxxxxxxx
11515                                                          ld1d.  */
11516                                                       return 1521;
11517                                                     }
11518                                                 }
11519                                             }
11520                                         }
11521                                     }
11522                                 }
11523                             }
11524                           else
11525                             {
11526                               if (((word >> 14) & 0x1) == 0)
11527                                 {
11528                                   if (((word >> 15) & 0x1) == 0)
11529                                     {
11530                                       if (((word >> 21) & 0x1) == 0)
11531                                         {
11532                                           if (((word >> 31) & 0x1) == 0)
11533                                             {
11534                                               if (((word >> 10) & 0x1) == 0)
11535                                                 {
11536                                                   if (((word >> 11) & 0x1) == 0)
11537                                                     {
11538                                                       /* 33222222222211111111110000000000
11539                                                          10987654321098765432109876543210
11540                                                          010001x1xx0xxxxx001x00xxxxxxxxxx
11541                                                          sabdlb.  */
11542                                                       return 2127;
11543                                                     }
11544                                                   else
11545                                                     {
11546                                                       /* 33222222222211111111110000000000
11547                                                          10987654321098765432109876543210
11548                                                          010001x1xx0xxxxx001x10xxxxxxxxxx
11549                                                          uabdlb.  */
11550                                                       return 2258;
11551                                                     }
11552                                                 }
11553                                               else
11554                                                 {
11555                                                   if (((word >> 11) & 0x1) == 0)
11556                                                     {
11557                                                       /* 33222222222211111111110000000000
11558                                                          10987654321098765432109876543210
11559                                                          010001x1xx0xxxxx001x01xxxxxxxxxx
11560                                                          sabdlt.  */
11561                                                       return 2128;
11562                                                     }
11563                                                   else
11564                                                     {
11565                                                       /* 33222222222211111111110000000000
11566                                                          10987654321098765432109876543210
11567                                                          010001x1xx0xxxxx001x11xxxxxxxxxx
11568                                                          uabdlt.  */
11569                                                       return 2259;
11570                                                     }
11571                                                 }
11572                                             }
11573                                           else
11574                                             {
11575                                               /* 33222222222211111111110000000000
11576                                                  10987654321098765432109876543210
11577                                                  110001x1xx0xxxxx001xxxxxxxxxxxxx
11578                                                  ldff1sw.  */
11579                                               return 1687;
11580                                             }
11581                                         }
11582                                       else
11583                                         {
11584                                           if (((word >> 31) & 0x1) == 0)
11585                                             {
11586                                               if (((word >> 10) & 0x1) == 0)
11587                                                 {
11588                                                   if (((word >> 11) & 0x1) == 0)
11589                                                     {
11590                                                       if (((word >> 12) & 0x1) == 0)
11591                                                         {
11592                                                           /* 33222222222211111111110000000000
11593                                                              10987654321098765432109876543210
11594                                                              010001x1xx1xxxxx001000xxxxxxxxxx
11595                                                              sqshrnb.  */
11596                                                           return 2218;
11597                                                         }
11598                                                       else
11599                                                         {
11600                                                           /* 33222222222211111111110000000000
11601                                                              10987654321098765432109876543210
11602                                                              010001x1xx1xxxxx001100xxxxxxxxxx
11603                                                              uqshrnb.  */
11604                                                           return 2297;
11605                                                         }
11606                                                     }
11607                                                   else
11608                                                     {
11609                                                       if (((word >> 12) & 0x1) == 0)
11610                                                         {
11611                                                           /* 33222222222211111111110000000000
11612                                                              10987654321098765432109876543210
11613                                                              010001x1xx1xxxxx001010xxxxxxxxxx
11614                                                              sqrshrnb.  */
11615                                                           return 2210;
11616                                                         }
11617                                                       else
11618                                                         {
11619                                                           /* 33222222222211111111110000000000
11620                                                              10987654321098765432109876543210
11621                                                              010001x1xx1xxxxx001110xxxxxxxxxx
11622                                                              uqrshrnb.  */
11623                                                           return 2292;
11624                                                         }
11625                                                     }
11626                                                 }
11627                                               else
11628                                                 {
11629                                                   if (((word >> 11) & 0x1) == 0)
11630                                                     {
11631                                                       if (((word >> 12) & 0x1) == 0)
11632                                                         {
11633                                                           /* 33222222222211111111110000000000
11634                                                              10987654321098765432109876543210
11635                                                              010001x1xx1xxxxx001001xxxxxxxxxx
11636                                                              sqshrnt.  */
11637                                                           return 2219;
11638                                                         }
11639                                                       else
11640                                                         {
11641                                                           /* 33222222222211111111110000000000
11642                                                              10987654321098765432109876543210
11643                                                              010001x1xx1xxxxx001101xxxxxxxxxx
11644                                                              uqshrnt.  */
11645                                                           return 2298;
11646                                                         }
11647                                                     }
11648                                                   else
11649                                                     {
11650                                                       if (((word >> 12) & 0x1) == 0)
11651                                                         {
11652                                                           /* 33222222222211111111110000000000
11653                                                              10987654321098765432109876543210
11654                                                              010001x1xx1xxxxx001011xxxxxxxxxx
11655                                                              sqrshrnt.  */
11656                                                           return 2211;
11657                                                         }
11658                                                       else
11659                                                         {
11660                                                           /* 33222222222211111111110000000000
11661                                                              10987654321098765432109876543210
11662                                                              010001x1xx1xxxxx001111xxxxxxxxxx
11663                                                              uqrshrnt.  */
11664                                                           return 2293;
11665                                                         }
11666                                                     }
11667                                                 }
11668                                             }
11669                                           else
11670                                             {
11671                                               /* 33222222222211111111110000000000
11672                                                  10987654321098765432109876543210
11673                                                  110001x1xx1xxxxx001xxxxxxxxxxxxx
11674                                                  ldff1sw.  */
11675                                               return 1688;
11676                                             }
11677                                         }
11678                                     }
11679                                   else
11680                                     {
11681                                       if (((word >> 21) & 0x1) == 0)
11682                                         {
11683                                           if (((word >> 31) & 0x1) == 0)
11684                                             {
11685                                               if (((word >> 10) & 0x1) == 0)
11686                                                 {
11687                                                   if (((word >> 11) & 0x1) == 0)
11688                                                     {
11689                                                       if (((word >> 12) & 0x1) == 0)
11690                                                         {
11691                                                           /* 33222222222211111111110000000000
11692                                                              10987654321098765432109876543210
11693                                                              010001x1xx0xxxxx101000xxxxxxxxxx
11694                                                              sshllb.  */
11695                                                           return 2234;
11696                                                         }
11697                                                       else
11698                                                         {
11699                                                           /* 33222222222211111111110000000000
11700                                                              10987654321098765432109876543210
11701                                                              010001x1xx0xxxxx101100xxxxxxxxxx
11702                                                              bext.  */
11703                                                           return 2339;
11704                                                         }
11705                                                     }
11706                                                   else
11707                                                     {
11708                                                       if (((word >> 12) & 0x1) == 0)
11709                                                         {
11710                                                           /* 33222222222211111111110000000000
11711                                                              10987654321098765432109876543210
11712                                                              010001x1xx0xxxxx101010xxxxxxxxxx
11713                                                              ushllb.  */
11714                                                           return 2310;
11715                                                         }
11716                                                       else
11717                                                         {
11718                                                           /* 33222222222211111111110000000000
11719                                                              10987654321098765432109876543210
11720                                                              010001x1xx0xxxxx101110xxxxxxxxxx
11721                                                              bgrp.  */
11722                                                           return 2340;
11723                                                         }
11724                                                     }
11725                                                 }
11726                                               else
11727                                                 {
11728                                                   if (((word >> 11) & 0x1) == 0)
11729                                                     {
11730                                                       if (((word >> 12) & 0x1) == 0)
11731                                                         {
11732                                                           /* 33222222222211111111110000000000
11733                                                              10987654321098765432109876543210
11734                                                              010001x1xx0xxxxx101001xxxxxxxxxx
11735                                                              sshllt.  */
11736                                                           return 2235;
11737                                                         }
11738                                                       else
11739                                                         {
11740                                                           /* 33222222222211111111110000000000
11741                                                              10987654321098765432109876543210
11742                                                              010001x1xx0xxxxx101101xxxxxxxxxx
11743                                                              bdep.  */
11744                                                           return 2338;
11745                                                         }
11746                                                     }
11747                                                   else
11748                                                     {
11749                                                       /* 33222222222211111111110000000000
11750                                                          10987654321098765432109876543210
11751                                                          010001x1xx0xxxxx101x11xxxxxxxxxx
11752                                                          ushllt.  */
11753                                                       return 2311;
11754                                                     }
11755                                                 }
11756                                             }
11757                                           else
11758                                             {
11759                                               /* 33222222222211111111110000000000
11760                                                  10987654321098765432109876543210
11761                                                  110001x1xx0xxxxx101xxxxxxxxxxxxx
11762                                                  ldff1sw.  */
11763                                               return 1689;
11764                                             }
11765                                         }
11766                                       else
11767                                         {
11768                                           if (((word >> 22) & 0x1) == 0)
11769                                             {
11770                                               if (((word >> 31) & 0x1) == 0)
11771                                                 {
11772                                                   /* 33222222222211111111110000000000
11773                                                      10987654321098765432109876543210
11774                                                      010001x1x01xxxxx101xxxxxxxxxxxxx
11775                                                      histseg.  */
11776                                                   return 2091;
11777                                                 }
11778                                               else
11779                                                 {
11780                                                   /* 33222222222211111111110000000000
11781                                                      10987654321098765432109876543210
11782                                                      110001x1x01xxxxx101xxxxxxxxxxxxx
11783                                                      ldff1sw.  */
11784                                                   return 1691;
11785                                                 }
11786                                             }
11787                                           else
11788                                             {
11789                                               /* 33222222222211111111110000000000
11790                                                  10987654321098765432109876543210
11791                                                  x10001x1x11xxxxx101xxxxxxxxxxxxx
11792                                                  ldff1sw.  */
11793                                               return 1690;
11794                                             }
11795                                         }
11796                                     }
11797                                 }
11798                               else
11799                                 {
11800                                   if (((word >> 15) & 0x1) == 0)
11801                                     {
11802                                       if (((word >> 21) & 0x1) == 0)
11803                                         {
11804                                           if (((word >> 31) & 0x1) == 0)
11805                                             {
11806                                               if (((word >> 10) & 0x1) == 0)
11807                                                 {
11808                                                   if (((word >> 11) & 0x1) == 0)
11809                                                     {
11810                                                       if (((word >> 12) & 0x1) == 0)
11811                                                         {
11812                                                           /* 33222222222211111111110000000000
11813                                                              10987654321098765432109876543210
11814                                                              010001x1xx0xxxxx011000xxxxxxxxxx
11815                                                              sqdmullb.  */
11816                                                           return 2188;
11817                                                         }
11818                                                       else
11819                                                         {
11820                                                           /* 33222222222211111111110000000000
11821                                                              10987654321098765432109876543210
11822                                                              010001x1xx0xxxxx011100xxxxxxxxxx
11823                                                              smullb.  */
11824                                                           return 2160;
11825                                                         }
11826                                                     }
11827                                                   else
11828                                                     {
11829                                                       if (((word >> 12) & 0x1) == 0)
11830                                                         {
11831                                                           if (((word >> 22) & 0x1) == 0)
11832                                                             {
11833                                                               /* 33222222222211111111110000000000
11834                                                                  10987654321098765432109876543210
11835                                                                  010001x1x00xxxxx011010xxxxxxxxxx
11836                                                                  pmullb.  */
11837                                                               return 2335;
11838                                                             }
11839                                                           else
11840                                                             {
11841                                                               /* 33222222222211111111110000000000
11842                                                                  10987654321098765432109876543210
11843                                                                  010001x1x10xxxxx011010xxxxxxxxxx
11844                                                                  pmullb.  */
11845                                                               return 2116;
11846                                                             }
11847                                                         }
11848                                                       else
11849                                                         {
11850                                                           /* 33222222222211111111110000000000
11851                                                              10987654321098765432109876543210
11852                                                              010001x1xx0xxxxx011110xxxxxxxxxx
11853                                                              umullb.  */
11854                                                           return 2285;
11855                                                         }
11856                                                     }
11857                                                 }
11858                                               else
11859                                                 {
11860                                                   if (((word >> 11) & 0x1) == 0)
11861                                                     {
11862                                                       if (((word >> 12) & 0x1) == 0)
11863                                                         {
11864                                                           /* 33222222222211111111110000000000
11865                                                              10987654321098765432109876543210
11866                                                              010001x1xx0xxxxx011001xxxxxxxxxx
11867                                                              sqdmullt.  */
11868                                                           return 2191;
11869                                                         }
11870                                                       else
11871                                                         {
11872                                                           /* 33222222222211111111110000000000
11873                                                              10987654321098765432109876543210
11874                                                              010001x1xx0xxxxx011101xxxxxxxxxx
11875                                                              smullt.  */
11876                                                           return 2163;
11877                                                         }
11878                                                     }
11879                                                   else
11880                                                     {
11881                                                       if (((word >> 12) & 0x1) == 0)
11882                                                         {
11883                                                           if (((word >> 22) & 0x1) == 0)
11884                                                             {
11885                                                               /* 33222222222211111111110000000000
11886                                                                  10987654321098765432109876543210
11887                                                                  010001x1x00xxxxx011011xxxxxxxxxx
11888                                                                  pmullt.  */
11889                                                               return 2336;
11890                                                             }
11891                                                           else
11892                                                             {
11893                                                               /* 33222222222211111111110000000000
11894                                                                  10987654321098765432109876543210
11895                                                                  010001x1x10xxxxx011011xxxxxxxxxx
11896                                                                  pmullt.  */
11897                                                               return 2117;
11898                                                             }
11899                                                         }
11900                                                       else
11901                                                         {
11902                                                           /* 33222222222211111111110000000000
11903                                                              10987654321098765432109876543210
11904                                                              010001x1xx0xxxxx011111xxxxxxxxxx
11905                                                              umullt.  */
11906                                                           return 2288;
11907                                                         }
11908                                                     }
11909                                                 }
11910                                             }
11911                                           else
11912                                             {
11913                                               if (((word >> 23) & 0x1) == 0)
11914                                                 {
11915                                                   /* 33222222222211111111110000000000
11916                                                      10987654321098765432109876543210
11917                                                      110001x10x0xxxxx011xxxxxxxxxxxxx
11918                                                      ldff1w.  */
11919                                                   return 1698;
11920                                                 }
11921                                               else
11922                                                 {
11923                                                   /* 33222222222211111111110000000000
11924                                                      10987654321098765432109876543210
11925                                                      110001x11x0xxxxx011xxxxxxxxxxxxx
11926                                                      ldff1d.  */
11927                                                   return 1643;
11928                                                 }
11929                                             }
11930                                         }
11931                                       else
11932                                         {
11933                                           if (((word >> 31) & 0x1) == 0)
11934                                             {
11935                                               if (((word >> 10) & 0x1) == 0)
11936                                                 {
11937                                                   if (((word >> 11) & 0x1) == 0)
11938                                                     {
11939                                                       if (((word >> 12) & 0x1) == 0)
11940                                                         {
11941                                                           /* 33222222222211111111110000000000
11942                                                              10987654321098765432109876543210
11943                                                              010001x1xx1xxxxx011000xxxxxxxxxx
11944                                                              addhnb.  */
11945                                                           return 2052;
11946                                                         }
11947                                                       else
11948                                                         {
11949                                                           /* 33222222222211111111110000000000
11950                                                              10987654321098765432109876543210
11951                                                              010001x1xx1xxxxx011100xxxxxxxxxx
11952                                                              subhnb.  */
11953                                                           return 2250;
11954                                                         }
11955                                                     }
11956                                                   else
11957                                                     {
11958                                                       if (((word >> 12) & 0x1) == 0)
11959                                                         {
11960                                                           /* 33222222222211111111110000000000
11961                                                              10987654321098765432109876543210
11962                                                              010001x1xx1xxxxx011010xxxxxxxxxx
11963                                                              raddhnb.  */
11964                                                           return 2118;
11965                                                         }
11966                                                       else
11967                                                         {
11968                                                           /* 33222222222211111111110000000000
11969                                                              10987654321098765432109876543210
11970                                                              010001x1xx1xxxxx011110xxxxxxxxxx
11971                                                              rsubhnb.  */
11972                                                           return 2122;
11973                                                         }
11974                                                     }
11975                                                 }
11976                                               else
11977                                                 {
11978                                                   if (((word >> 11) & 0x1) == 0)
11979                                                     {
11980                                                       if (((word >> 12) & 0x1) == 0)
11981                                                         {
11982                                                           /* 33222222222211111111110000000000
11983                                                              10987654321098765432109876543210
11984                                                              010001x1xx1xxxxx011001xxxxxxxxxx
11985                                                              addhnt.  */
11986                                                           return 2053;
11987                                                         }
11988                                                       else
11989                                                         {
11990                                                           /* 33222222222211111111110000000000
11991                                                              10987654321098765432109876543210
11992                                                              010001x1xx1xxxxx011101xxxxxxxxxx
11993                                                              subhnt.  */
11994                                                           return 2251;
11995                                                         }
11996                                                     }
11997                                                   else
11998                                                     {
11999                                                       if (((word >> 12) & 0x1) == 0)
12000                                                         {
12001                                                           /* 33222222222211111111110000000000
12002                                                              10987654321098765432109876543210
12003                                                              010001x1xx1xxxxx011011xxxxxxxxxx
12004                                                              raddhnt.  */
12005                                                           return 2119;
12006                                                         }
12007                                                       else
12008                                                         {
12009                                                           /* 33222222222211111111110000000000
12010                                                              10987654321098765432109876543210
12011                                                              010001x1xx1xxxxx011111xxxxxxxxxx
12012                                                              rsubhnt.  */
12013                                                           return 2123;
12014                                                         }
12015                                                     }
12016                                                 }
12017                                             }
12018                                           else
12019                                             {
12020                                               if (((word >> 23) & 0x1) == 0)
12021                                                 {
12022                                                   /* 33222222222211111111110000000000
12023                                                      10987654321098765432109876543210
12024                                                      110001x10x1xxxxx011xxxxxxxxxxxxx
12025                                                      ldff1w.  */
12026                                                   return 1699;
12027                                                 }
12028                                               else
12029                                                 {
12030                                                   /* 33222222222211111111110000000000
12031                                                      10987654321098765432109876543210
12032                                                      110001x11x1xxxxx011xxxxxxxxxxxxx
12033                                                      ldff1d.  */
12034                                                   return 1644;
12035                                                 }
12036                                             }
12037                                         }
12038                                     }
12039                                   else
12040                                     {
12041                                       if (((word >> 21) & 0x1) == 0)
12042                                         {
12043                                           if (((word >> 31) & 0x1) == 0)
12044                                             {
12045                                               if (((word >> 10) & 0x1) == 0)
12046                                                 {
12047                                                   if (((word >> 11) & 0x1) == 0)
12048                                                     {
12049                                                       if (((word >> 12) & 0x1) == 0)
12050                                                         {
12051                                                           /* 33222222222211111111110000000000
12052                                                              10987654321098765432109876543210
12053                                                              010001x1xx0xxxxx111000xxxxxxxxxx
12054                                                              ssra.  */
12055                                                           return 2236;
12056                                                         }
12057                                                       else
12058                                                         {
12059                                                           /* 33222222222211111111110000000000
12060                                                              10987654321098765432109876543210
12061                                                              010001x1xx0xxxxx111100xxxxxxxxxx
12062                                                              sri.  */
12063                                                           return 2229;
12064                                                         }
12065                                                     }
12066                                                   else
12067                                                     {
12068                                                       if (((word >> 12) & 0x1) == 0)
12069                                                         {
12070                                                           /* 33222222222211111111110000000000
12071                                                              10987654321098765432109876543210
12072                                                              010001x1xx0xxxxx111010xxxxxxxxxx
12073                                                              srsra.  */
12074                                                           return 2233;
12075                                                         }
12076                                                       else
12077                                                         {
12078                                                           /* 33222222222211111111110000000000
12079                                                              10987654321098765432109876543210
12080                                                              010001x1xx0xxxxx111110xxxxxxxxxx
12081                                                              saba.  */
12082                                                           return 2124;
12083                                                         }
12084                                                     }
12085                                                 }
12086                                               else
12087                                                 {
12088                                                   if (((word >> 11) & 0x1) == 0)
12089                                                     {
12090                                                       if (((word >> 12) & 0x1) == 0)
12091                                                         {
12092                                                           /* 33222222222211111111110000000000
12093                                                              10987654321098765432109876543210
12094                                                              010001x1xx0xxxxx111001xxxxxxxxxx
12095                                                              usra.  */
12096                                                           return 2313;
12097                                                         }
12098                                                       else
12099                                                         {
12100                                                           /* 33222222222211111111110000000000
12101                                                              10987654321098765432109876543210
12102                                                              010001x1xx0xxxxx111101xxxxxxxxxx
12103                                                              sli.  */
12104                                                           return 2142;
12105                                                         }
12106                                                     }
12107                                                   else
12108                                                     {
12109                                                       if (((word >> 12) & 0x1) == 0)
12110                                                         {
12111                                                           /* 33222222222211111111110000000000
12112                                                              10987654321098765432109876543210
12113                                                              010001x1xx0xxxxx111011xxxxxxxxxx
12114                                                              ursra.  */
12115                                                           return 2309;
12116                                                         }
12117                                                       else
12118                                                         {
12119                                                           /* 33222222222211111111110000000000
12120                                                              10987654321098765432109876543210
12121                                                              010001x1xx0xxxxx111111xxxxxxxxxx
12122                                                              uaba.  */
12123                                                           return 2255;
12124                                                         }
12125                                                     }
12126                                                 }
12127                                             }
12128                                           else
12129                                             {
12130                                               if (((word >> 22) & 0x1) == 0)
12131                                                 {
12132                                                   if (((word >> 23) & 0x1) == 0)
12133                                                     {
12134                                                       /* 33222222222211111111110000000000
12135                                                          10987654321098765432109876543210
12136                                                          110001x1000xxxxx111xxxxxxxxxxxxx
12137                                                          prfw.  */
12138                                                       return 1794;
12139                                                     }
12140                                                   else
12141                                                     {
12142                                                       /* 33222222222211111111110000000000
12143                                                          10987654321098765432109876543210
12144                                                          110001x1100xxxxx111xxxxxxxxxxxxx
12145                                                          prfd.  */
12146                                                       return 1780;
12147                                                     }
12148                                                 }
12149                                               else
12150                                                 {
12151                                                   if (((word >> 23) & 0x1) == 0)
12152                                                     {
12153                                                       /* 33222222222211111111110000000000
12154                                                          10987654321098765432109876543210
12155                                                          110001x1010xxxxx111xxxxxxxxxxxxx
12156                                                          ldff1w.  */
12157                                                       return 1700;
12158                                                     }
12159                                                   else
12160                                                     {
12161                                                       /* 33222222222211111111110000000000
12162                                                          10987654321098765432109876543210
12163                                                          110001x1110xxxxx111xxxxxxxxxxxxx
12164                                                          ldff1d.  */
12165                                                       return 1645;
12166                                                     }
12167                                                 }
12168                                             }
12169                                         }
12170                                       else
12171                                         {
12172                                           if (((word >> 22) & 0x1) == 0)
12173                                             {
12174                                               if (((word >> 23) & 0x1) == 0)
12175                                                 {
12176                                                   if (((word >> 31) & 0x1) == 0)
12177                                                     {
12178                                                       if (((word >> 10) & 0x1) == 0)
12179                                                         {
12180                                                           if (((word >> 12) & 0x1) == 0)
12181                                                             {
12182                                                               if (((word >> 16) & 0x1) == 0)
12183                                                                 {
12184                                                                   if (((word >> 17) & 0x1) == 0)
12185                                                                     {
12186                                                                       /* 33222222222211111111110000000000
12187                                                                          10987654321098765432109876543210
12188                                                                          010001x1001xxx001110x0xxxxxxxxxx
12189                                                                          aesmc.  */
12190                                                                       return 2334;
12191                                                                     }
12192                                                                   else
12193                                                                     {
12194                                                                       /* 33222222222211111111110000000000
12195                                                                          10987654321098765432109876543210
12196                                                                          010001x1001xxx101110x0xxxxxxxxxx
12197                                                                          aese.  */
12198                                                                       return 2332;
12199                                                                     }
12200                                                                 }
12201                                                               else
12202                                                                 {
12203                                                                   /* 33222222222211111111110000000000
12204                                                                      10987654321098765432109876543210
12205                                                                      010001x1001xxxx11110x0xxxxxxxxxx
12206                                                                      sm4e.  */
12207                                                                   return 2329;
12208                                                                 }
12209                                                             }
12210                                                           else
12211                                                             {
12212                                                               /* 33222222222211111111110000000000
12213                                                                  10987654321098765432109876543210
12214                                                                  010001x1001xxxxx1111x0xxxxxxxxxx
12215                                                                  sm4ekey.  */
12216                                                               return 2330;
12217                                                             }
12218                                                         }
12219                                                       else
12220                                                         {
12221                                                           if (((word >> 12) & 0x1) == 0)
12222                                                             {
12223                                                               if (((word >> 17) & 0x1) == 0)
12224                                                                 {
12225                                                                   /* 33222222222211111111110000000000
12226                                                                      10987654321098765432109876543210
12227                                                                      010001x1001xxx0x1110x1xxxxxxxxxx
12228                                                                      aesimc.  */
12229                                                                   return 2333;
12230                                                                 }
12231                                                               else
12232                                                                 {
12233                                                                   /* 33222222222211111111110000000000
12234                                                                      10987654321098765432109876543210
12235                                                                      010001x1001xxx1x1110x1xxxxxxxxxx
12236                                                                      aesd.  */
12237                                                                   return 2331;
12238                                                                 }
12239                                                             }
12240                                                           else
12241                                                             {
12242                                                               /* 33222222222211111111110000000000
12243                                                                  10987654321098765432109876543210
12244                                                                  010001x1001xxxxx1111x1xxxxxxxxxx
12245                                                                  rax1.  */
12246                                                               return 2337;
12247                                                             }
12248                                                         }
12249                                                     }
12250                                                   else
12251                                                     {
12252                                                       /* 33222222222211111111110000000000
12253                                                          10987654321098765432109876543210
12254                                                          110001x1001xxxxx111xxxxxxxxxxxxx
12255                                                          ldff1w.  */
12256                                                       return 1703;
12257                                                     }
12258                                                 }
12259                                               else
12260                                                 {
12261                                                   /* 33222222222211111111110000000000
12262                                                      10987654321098765432109876543210
12263                                                      x10001x1101xxxxx111xxxxxxxxxxxxx
12264                                                      ldff1d.  */
12265                                                   return 1647;
12266                                                 }
12267                                             }
12268                                           else
12269                                             {
12270                                               if (((word >> 23) & 0x1) == 0)
12271                                                 {
12272                                                   /* 33222222222211111111110000000000
12273                                                      10987654321098765432109876543210
12274                                                      x10001x1011xxxxx111xxxxxxxxxxxxx
12275                                                      ldff1w.  */
12276                                                   return 1701;
12277                                                 }
12278                                               else
12279                                                 {
12280                                                   /* 33222222222211111111110000000000
12281                                                      10987654321098765432109876543210
12282                                                      x10001x1111xxxxx111xxxxxxxxxxxxx
12283                                                      ldff1d.  */
12284                                                   return 1646;
12285                                                 }
12286                                             }
12287                                         }
12288                                     }
12289                                 }
12290                             }
12291                         }
12292                     }
12293                   else
12294                     {
12295                       if (((word >> 15) & 0x1) == 0)
12296                         {
12297                           if (((word >> 14) & 0x1) == 0)
12298                             {
12299                               if (((word >> 13) & 0x1) == 0)
12300                                 {
12301                                   if (((word >> 30) & 0x1) == 0)
12302                                     {
12303                                       if (((word >> 21) & 0x1) == 0)
12304                                         {
12305                                           if (((word >> 31) & 0x1) == 0)
12306                                             {
12307                                               if (((word >> 4) & 0x1) == 0)
12308                                                 {
12309                                                   /* 33222222222211111111110000000000
12310                                                      10987654321098765432109876543210
12311                                                      001001x1xx0xxxxx000xxxxxxxx0xxxx
12312                                                      cmpge.  */
12313                                                   return 1326;
12314                                                 }
12315                                               else
12316                                                 {
12317                                                   /* 33222222222211111111110000000000
12318                                                      10987654321098765432109876543210
12319                                                      001001x1xx0xxxxx000xxxxxxxx1xxxx
12320                                                      cmpgt.  */
12321                                                   return 1329;
12322                                                 }
12323                                             }
12324                                           else
12325                                             {
12326                                               if (((word >> 23) & 0x1) == 0)
12327                                                 {
12328                                                   /* 33222222222211111111110000000000
12329                                                      10987654321098765432109876543210
12330                                                      101001x10x0xxxxx000xxxxxxxxxxxxx
12331                                                      ld1rqw.  */
12332                                                   return 1553;
12333                                                 }
12334                                               else
12335                                                 {
12336                                                   /* 33222222222211111111110000000000
12337                                                      10987654321098765432109876543210
12338                                                      101001x11x0xxxxx000xxxxxxxxxxxxx
12339                                                      ld1rqd.  */
12340                                                   return 1549;
12341                                                 }
12342                                             }
12343                                         }
12344                                       else
12345                                         {
12346                                           if (((word >> 31) & 0x1) == 0)
12347                                             {
12348                                               if (((word >> 4) & 0x1) == 0)
12349                                                 {
12350                                                   if (((word >> 10) & 0x1) == 0)
12351                                                     {
12352                                                       if (((word >> 11) & 0x1) == 0)
12353                                                         {
12354                                                           if (((word >> 12) & 0x1) == 0)
12355                                                             {
12356                                                               /* 33222222222211111111110000000000
12357                                                                  10987654321098765432109876543210
12358                                                                  001001x1xx1xxxxx000000xxxxx0xxxx
12359                                                                  whilege.  */
12360                                                               return 2318;
12361                                                             }
12362                                                           else
12363                                                             {
12364                                                               /* 33222222222211111111110000000000
12365                                                                  10987654321098765432109876543210
12366                                                                  001001x1xx1xxxxx000100xxxxx0xxxx
12367                                                                  whilege.  */
12368                                                               return 2319;
12369                                                             }
12370                                                         }
12371                                                       else
12372                                                         {
12373                                                           if (((word >> 12) & 0x1) == 0)
12374                                                             {
12375                                                               /* 33222222222211111111110000000000
12376                                                                  10987654321098765432109876543210
12377                                                                  001001x1xx1xxxxx000010xxxxx0xxxx
12378                                                                  whilehs.  */
12379                                                               return 2324;
12380                                                             }
12381                                                           else
12382                                                             {
12383                                                               /* 33222222222211111111110000000000
12384                                                                  10987654321098765432109876543210
12385                                                                  001001x1xx1xxxxx000110xxxxx0xxxx
12386                                                                  whilehs.  */
12387                                                               return 2325;
12388                                                             }
12389                                                         }
12390                                                     }
12391                                                   else
12392                                                     {
12393                                                       if (((word >> 11) & 0x1) == 0)
12394                                                         {
12395                                                           if (((word >> 12) & 0x1) == 0)
12396                                                             {
12397                                                               /* 33222222222211111111110000000000
12398                                                                  10987654321098765432109876543210
12399                                                                  001001x1xx1xxxxx000001xxxxx0xxxx
12400                                                                  whilelt.  */
12401                                                               return 2030;
12402                                                             }
12403                                                           else
12404                                                             {
12405                                                               /* 33222222222211111111110000000000
12406                                                                  10987654321098765432109876543210
12407                                                                  001001x1xx1xxxxx000101xxxxx0xxxx
12408                                                                  whilelt.  */
12409                                                               return 2031;
12410                                                             }
12411                                                         }
12412                                                       else
12413                                                         {
12414                                                           if (((word >> 12) & 0x1) == 0)
12415                                                             {
12416                                                               /* 33222222222211111111110000000000
12417                                                                  10987654321098765432109876543210
12418                                                                  001001x1xx1xxxxx000011xxxxx0xxxx
12419                                                                  whilelo.  */
12420                                                               return 2026;
12421                                                             }
12422                                                           else
12423                                                             {
12424                                                               /* 33222222222211111111110000000000
12425                                                                  10987654321098765432109876543210
12426                                                                  001001x1xx1xxxxx000111xxxxx0xxxx
12427                                                                  whilelo.  */
12428                                                               return 2027;
12429                                                             }
12430                                                         }
12431                                                     }
12432                                                 }
12433                                               else
12434                                                 {
12435                                                   if (((word >> 10) & 0x1) == 0)
12436                                                     {
12437                                                       if (((word >> 11) & 0x1) == 0)
12438                                                         {
12439                                                           if (((word >> 12) & 0x1) == 0)
12440                                                             {
12441                                                               /* 33222222222211111111110000000000
12442                                                                  10987654321098765432109876543210
12443                                                                  001001x1xx1xxxxx000000xxxxx1xxxx
12444                                                                  whilegt.  */
12445                                                               return 2320;
12446                                                             }
12447                                                           else
12448                                                             {
12449                                                               /* 33222222222211111111110000000000
12450                                                                  10987654321098765432109876543210
12451                                                                  001001x1xx1xxxxx000100xxxxx1xxxx
12452                                                                  whilegt.  */
12453                                                               return 2321;
12454                                                             }
12455                                                         }
12456                                                       else
12457                                                         {
12458                                                           if (((word >> 12) & 0x1) == 0)
12459                                                             {
12460                                                               /* 33222222222211111111110000000000
12461                                                                  10987654321098765432109876543210
12462                                                                  001001x1xx1xxxxx000010xxxxx1xxxx
12463                                                                  whilehi.  */
12464                                                               return 2322;
12465                                                             }
12466                                                           else
12467                                                             {
12468                                                               /* 33222222222211111111110000000000
12469                                                                  10987654321098765432109876543210
12470                                                                  001001x1xx1xxxxx000110xxxxx1xxxx
12471                                                                  whilehi.  */
12472                                                               return 2323;
12473                                                             }
12474                                                         }
12475                                                     }
12476                                                   else
12477                                                     {
12478                                                       if (((word >> 11) & 0x1) == 0)
12479                                                         {
12480                                                           if (((word >> 12) & 0x1) == 0)
12481                                                             {
12482                                                               /* 33222222222211111111110000000000
12483                                                                  10987654321098765432109876543210
12484                                                                  001001x1xx1xxxxx000001xxxxx1xxxx
12485                                                                  whilele.  */
12486                                                               return 2024;
12487                                                             }
12488                                                           else
12489                                                             {
12490                                                               /* 33222222222211111111110000000000
12491                                                                  10987654321098765432109876543210
12492                                                                  001001x1xx1xxxxx000101xxxxx1xxxx
12493                                                                  whilele.  */
12494                                                               return 2025;
12495                                                             }
12496                                                         }
12497                                                       else
12498                                                         {
12499                                                           if (((word >> 12) & 0x1) == 0)
12500                                                             {
12501                                                               /* 33222222222211111111110000000000
12502                                                                  10987654321098765432109876543210
12503                                                                  001001x1xx1xxxxx000011xxxxx1xxxx
12504                                                                  whilels.  */
12505                                                               return 2028;
12506                                                             }
12507                                                           else
12508                                                             {
12509                                                               /* 33222222222211111111110000000000
12510                                                                  10987654321098765432109876543210
12511                                                                  001001x1xx1xxxxx000111xxxxx1xxxx
12512                                                                  whilels.  */
12513                                                               return 2029;
12514                                                             }
12515                                                         }
12516                                                     }
12517                                                 }
12518                                             }
12519                                           else
12520                                             {
12521                                               if (((word >> 23) & 0x1) == 0)
12522                                                 {
12523                                                   /* 33222222222211111111110000000000
12524                                                      10987654321098765432109876543210
12525                                                      101001x10x1xxxxx000xxxxxxxxxxxxx
12526                                                      ld1row.  */
12527                                                   return 2404;
12528                                                 }
12529                                               else
12530                                                 {
12531                                                   /* 33222222222211111111110000000000
12532                                                      10987654321098765432109876543210
12533                                                      101001x11x1xxxxx000xxxxxxxxxxxxx
12534                                                      ld1rod.  */
12535                                                   return 2405;
12536                                                 }
12537                                             }
12538                                         }
12539                                     }
12540                                   else
12541                                     {
12542                                       if (((word >> 31) & 0x1) == 0)
12543                                         {
12544                                           if (((word >> 21) & 0x1) == 0)
12545                                             {
12546                                               if (((word >> 10) & 0x1) == 0)
12547                                                 {
12548                                                   if (((word >> 11) & 0x1) == 0)
12549                                                     {
12550                                                       /* 33222222222211111111110000000000
12551                                                          10987654321098765432109876543210
12552                                                          011001x1xx0xxxxx000x00xxxxxxxxxx
12553                                                          fadd.  */
12554                                                       return 1384;
12555                                                     }
12556                                                   else
12557                                                     {
12558                                                       if (((word >> 12) & 0x1) == 0)
12559                                                         {
12560                                                           /* 33222222222211111111110000000000
12561                                                              10987654321098765432109876543210
12562                                                              011001x1xx0xxxxx000010xxxxxxxxxx
12563                                                              fmul.  */
12564                                                           return 1451;
12565                                                         }
12566                                                       else
12567                                                         {
12568                                                           /* 33222222222211111111110000000000
12569                                                              10987654321098765432109876543210
12570                                                              011001x1xx0xxxxx000110xxxxxxxxxx
12571                                                              frecps.  */
12572                                                           return 1464;
12573                                                         }
12574                                                     }
12575                                                 }
12576                                               else
12577                                                 {
12578                                                   if (((word >> 11) & 0x1) == 0)
12579                                                     {
12580                                                       /* 33222222222211111111110000000000
12581                                                          10987654321098765432109876543210
12582                                                          011001x1xx0xxxxx000x01xxxxxxxxxx
12583                                                          fsub.  */
12584                                                       return 1477;
12585                                                     }
12586                                                   else
12587                                                     {
12588                                                       if (((word >> 12) & 0x1) == 0)
12589                                                         {
12590                                                           /* 33222222222211111111110000000000
12591                                                              10987654321098765432109876543210
12592                                                              011001x1xx0xxxxx000011xxxxxxxxxx
12593                                                              ftsmul.  */
12594                                                           return 1483;
12595                                                         }
12596                                                       else
12597                                                         {
12598                                                           /* 33222222222211111111110000000000
12599                                                              10987654321098765432109876543210
12600                                                              011001x1xx0xxxxx000111xxxxxxxxxx
12601                                                              frsqrts.  */
12602                                                           return 1474;
12603                                                         }
12604                                                     }
12605                                                 }
12606                                             }
12607                                           else
12608                                             {
12609                                               /* 33222222222211111111110000000000
12610                                                  10987654321098765432109876543210
12611                                                  011001x1xx1xxxxx000xxxxxxxxxxxxx
12612                                                  fmla.  */
12613                                               return 1442;
12614                                             }
12615                                         }
12616                                       else
12617                                         {
12618                                           /* 33222222222211111111110000000000
12619                                              10987654321098765432109876543210
12620                                              111001x1xxxxxxxx000xxxxxxxxxxxxx
12621                                              str.  */
12622                                           return 1945;
12623                                         }
12624                                     }
12625                                 }
12626                               else
12627                                 {
12628                                   if (((word >> 21) & 0x1) == 0)
12629                                     {
12630                                       if (((word >> 30) & 0x1) == 0)
12631                                         {
12632                                           if (((word >> 31) & 0x1) == 0)
12633                                             {
12634                                               if (((word >> 4) & 0x1) == 0)
12635                                                 {
12636                                                   /* 33222222222211111111110000000000
12637                                                      10987654321098765432109876543210
12638                                                      001001x1xx0xxxxx001xxxxxxxx0xxxx
12639                                                      cmplt.  */
12640                                                   return 1343;
12641                                                 }
12642                                               else
12643                                                 {
12644                                                   /* 33222222222211111111110000000000
12645                                                      10987654321098765432109876543210
12646                                                      001001x1xx0xxxxx001xxxxxxxx1xxxx
12647                                                      cmple.  */
12648                                                   return 1337;
12649                                                 }
12650                                             }
12651                                           else
12652                                             {
12653                                               if (((word >> 23) & 0x1) == 0)
12654                                                 {
12655                                                   /* 33222222222211111111110000000000
12656                                                      10987654321098765432109876543210
12657                                                      101001x10x0xxxxx001xxxxxxxxxxxxx
12658                                                      ld1rqw.  */
12659                                                   return 1552;
12660                                                 }
12661                                               else
12662                                                 {
12663                                                   /* 33222222222211111111110000000000
12664                                                      10987654321098765432109876543210
12665                                                      101001x11x0xxxxx001xxxxxxxxxxxxx
12666                                                      ld1rqd.  */
12667                                                   return 1548;
12668                                                 }
12669                                             }
12670                                         }
12671                                       else
12672                                         {
12673                                           if (((word >> 31) & 0x1) == 0)
12674                                             {
12675                                               if (((word >> 16) & 0x1) == 0)
12676                                                 {
12677                                                   if (((word >> 17) & 0x1) == 0)
12678                                                     {
12679                                                       if (((word >> 18) & 0x1) == 0)
12680                                                         {
12681                                                           if (((word >> 19) & 0x1) == 0)
12682                                                             {
12683                                                               if (((word >> 20) & 0x1) == 0)
12684                                                                 {
12685                                                                   /* 33222222222211111111110000000000
12686                                                                      10987654321098765432109876543210
12687                                                                      011001x1xx000000001xxxxxxxxxxxxx
12688                                                                      faddv.  */
12689                                                                   return 1388;
12690                                                                 }
12691                                                               else
12692                                                                 {
12693                                                                   if (((word >> 4) & 0x1) == 0)
12694                                                                     {
12695                                                                       /* 33222222222211111111110000000000
12696                                                                          10987654321098765432109876543210
12697                                                                          011001x1xx010000001xxxxxxxx0xxxx
12698                                                                          fcmge.  */
12699                                                                       return 1395;
12700                                                                     }
12701                                                                   else
12702                                                                     {
12703                                                                       /* 33222222222211111111110000000000
12704                                                                          10987654321098765432109876543210
12705                                                                          011001x1xx010000001xxxxxxxx1xxxx
12706                                                                          fcmgt.  */
12707                                                                       return 1397;
12708                                                                     }
12709                                                                 }
12710                                                             }
12711                                                           else
12712                                                             {
12713                                                               /* 33222222222211111111110000000000
12714                                                                  10987654321098765432109876543210
12715                                                                  011001x1xx0x1000001xxxxxxxxxxxxx
12716                                                                  fadda.  */
12717                                                               return 1387;
12718                                                             }
12719                                                         }
12720                                                       else
12721                                                         {
12722                                                           /* 33222222222211111111110000000000
12723                                                              10987654321098765432109876543210
12724                                                              011001x1xx0xx100001xxxxxxxxxxxxx
12725                                                              fmaxnmv.  */
12726                                                           return 1434;
12727                                                         }
12728                                                     }
12729                                                   else
12730                                                     {
12731                                                       if (((word >> 18) & 0x1) == 0)
12732                                                         {
12733                                                           /* 33222222222211111111110000000000
12734                                                              10987654321098765432109876543210
12735                                                              011001x1xx0xx010001xxxxxxxxxxxxx
12736                                                              fcmeq.  */
12737                                                           return 1393;
12738                                                         }
12739                                                       else
12740                                                         {
12741                                                           if (((word >> 19) & 0x1) == 0)
12742                                                             {
12743                                                               /* 33222222222211111111110000000000
12744                                                                  10987654321098765432109876543210
12745                                                                  011001x1xx0x0110001xxxxxxxxxxxxx
12746                                                                  fmaxv.  */
12747                                                               return 1435;
12748                                                             }
12749                                                           else
12750                                                             {
12751                                                               /* 33222222222211111111110000000000
12752                                                                  10987654321098765432109876543210
12753                                                                  011001x1xx0x1110001xxxxxxxxxxxxx
12754                                                                  frecpe.  */
12755                                                               return 1463;
12756                                                             }
12757                                                         }
12758                                                     }
12759                                                 }
12760                                               else
12761                                                 {
12762                                                   if (((word >> 17) & 0x1) == 0)
12763                                                     {
12764                                                       if (((word >> 18) & 0x1) == 0)
12765                                                         {
12766                                                           if (((word >> 4) & 0x1) == 0)
12767                                                             {
12768                                                               /* 33222222222211111111110000000000
12769                                                                  10987654321098765432109876543210
12770                                                                  011001x1xx0xx001001xxxxxxxx0xxxx
12771                                                                  fcmlt.  */
12772                                                               return 1400;
12773                                                             }
12774                                                           else
12775                                                             {
12776                                                               /* 33222222222211111111110000000000
12777                                                                  10987654321098765432109876543210
12778                                                                  011001x1xx0xx001001xxxxxxxx1xxxx
12779                                                                  fcmle.  */
12780                                                               return 1399;
12781                                                             }
12782                                                         }
12783                                                       else
12784                                                         {
12785                                                           /* 33222222222211111111110000000000
12786                                                              10987654321098765432109876543210
12787                                                              011001x1xx0xx101001xxxxxxxxxxxxx
12788                                                              fminnmv.  */
12789                                                           return 1440;
12790                                                         }
12791                                                     }
12792                                                   else
12793                                                     {
12794                                                       if (((word >> 18) & 0x1) == 0)
12795                                                         {
12796                                                           /* 33222222222211111111110000000000
12797                                                              10987654321098765432109876543210
12798                                                              011001x1xx0xx011001xxxxxxxxxxxxx
12799                                                              fcmne.  */
12800                                                           return 1401;
12801                                                         }
12802                                                       else
12803                                                         {
12804                                                           if (((word >> 19) & 0x1) == 0)
12805                                                             {
12806                                                               /* 33222222222211111111110000000000
12807                                                                  10987654321098765432109876543210
12808                                                                  011001x1xx0x0111001xxxxxxxxxxxxx
12809                                                                  fminv.  */
12810                                                               return 1441;
12811                                                             }
12812                                                           else
12813                                                             {
12814                                                               /* 33222222222211111111110000000000
12815                                                                  10987654321098765432109876543210
12816                                                                  011001x1xx0x1111001xxxxxxxxxxxxx
12817                                                                  frsqrte.  */
12818                                                               return 1473;
12819                                                             }
12820                                                         }
12821                                                     }
12822                                                 }
12823                                             }
12824                                           else
12825                                             {
12826                                               if (((word >> 22) & 0x1) == 0)
12827                                                 {
12828                                                   if (((word >> 23) & 0x1) == 0)
12829                                                     {
12830                                                       /* 33222222222211111111110000000000
12831                                                          10987654321098765432109876543210
12832                                                          111001x1000xxxxx001xxxxxxxxxxxxx
12833                                                          stnt1w.  */
12834                                                       return 2249;
12835                                                     }
12836                                                   else
12837                                                     {
12838                                                       /* 33222222222211111111110000000000
12839                                                          10987654321098765432109876543210
12840                                                          111001x1100xxxxx001xxxxxxxxxxxxx
12841                                                          stnt1d.  */
12842                                                       return 2245;
12843                                                     }
12844                                                 }
12845                                               else
12846                                                 {
12847                                                   /* 33222222222211111111110000000000
12848                                                      10987654321098765432109876543210
12849                                                      111001x1x10xxxxx001xxxxxxxxxxxxx
12850                                                      stnt1w.  */
12851                                                   return 2248;
12852                                                 }
12853                                             }
12854                                         }
12855                                     }
12856                                   else
12857                                     {
12858                                       if (((word >> 30) & 0x1) == 0)
12859                                         {
12860                                           if (((word >> 31) & 0x1) == 0)
12861                                             {
12862                                               if (((word >> 4) & 0x1) == 0)
12863                                                 {
12864                                                   if (((word >> 12) & 0x1) == 0)
12865                                                     {
12866                                                       /* 33222222222211111111110000000000
12867                                                          10987654321098765432109876543210
12868                                                          001001x1xx1xxxxx0010xxxxxxx0xxxx
12869                                                          ctermeq.  */
12870                                                       return 1358;
12871                                                     }
12872                                                   else
12873                                                     {
12874                                                       /* 33222222222211111111110000000000
12875                                                          10987654321098765432109876543210
12876                                                          001001x1xx1xxxxx0011xxxxxxx0xxxx
12877                                                          whilewr.  */
12878                                                       return 2327;
12879                                                     }
12880                                                 }
12881                                               else
12882                                                 {
12883                                                   if (((word >> 12) & 0x1) == 0)
12884                                                     {
12885                                                       /* 33222222222211111111110000000000
12886                                                          10987654321098765432109876543210
12887                                                          001001x1xx1xxxxx0010xxxxxxx1xxxx
12888                                                          ctermne.  */
12889                                                       return 1359;
12890                                                     }
12891                                                   else
12892                                                     {
12893                                                       /* 33222222222211111111110000000000
12894                                                          10987654321098765432109876543210
12895                                                          001001x1xx1xxxxx0011xxxxxxx1xxxx
12896                                                          whilerw.  */
12897                                                       return 2326;
12898                                                     }
12899                                                 }
12900                                             }
12901                                           else
12902                                             {
12903                                               if (((word >> 23) & 0x1) == 0)
12904                                                 {
12905                                                   /* 33222222222211111111110000000000
12906                                                      10987654321098765432109876543210
12907                                                      101001x10x1xxxxx001xxxxxxxxxxxxx
12908                                                      ld1row.  */
12909                                                   return 2408;
12910                                                 }
12911                                               else
12912                                                 {
12913                                                   /* 33222222222211111111110000000000
12914                                                      10987654321098765432109876543210
12915                                                      101001x11x1xxxxx001xxxxxxxxxxxxx
12916                                                      ld1rod.  */
12917                                                   return 2409;
12918                                                 }
12919                                             }
12920                                         }
12921                                       else
12922                                         {
12923                                           /* 33222222222211111111110000000000
12924                                              10987654321098765432109876543210
12925                                              x11001x1xx1xxxxx001xxxxxxxxxxxxx
12926                                              fmls.  */
12927                                           return 1446;
12928                                         }
12929                                     }
12930                                 }
12931                             }
12932                           else
12933                             {
12934                               if (((word >> 30) & 0x1) == 0)
12935                                 {
12936                                   if (((word >> 21) & 0x1) == 0)
12937                                     {
12938                                       if (((word >> 22) & 0x1) == 0)
12939                                         {
12940                                           if (((word >> 23) & 0x1) == 0)
12941                                             {
12942                                               if (((word >> 31) & 0x1) == 0)
12943                                                 {
12944                                                   if (((word >> 9) & 0x1) == 0)
12945                                                     {
12946                                                       if (((word >> 20) & 0x1) == 0)
12947                                                         {
12948                                                           if (((word >> 4) & 0x1) == 0)
12949                                                             {
12950                                                               /* 33222222222211111111110000000000
12951                                                                  10987654321098765432109876543210
12952                                                                  001001x10000xxxx01xxxx0xxxx0xxxx
12953                                                                  and.  */
12954                                                               return 1289;
12955                                                             }
12956                                                           else
12957                                                             {
12958                                                               /* 33222222222211111111110000000000
12959                                                                  10987654321098765432109876543210
12960                                                                  001001x10000xxxx01xxxx0xxxx1xxxx
12961                                                                  bic.  */
12962                                                               return 1301;
12963                                                             }
12964                                                         }
12965                                                       else
12966                                                         {
12967                                                           if (((word >> 19) & 0x1) == 0)
12968                                                             {
12969                                                               /* 33222222222211111111110000000000
12970                                                                  10987654321098765432109876543210
12971                                                                  001001x100010xxx01xxxx0xxxxxxxxx
12972                                                                  brka.  */
12973                                                               return 1303;
12974                                                             }
12975                                                           else
12976                                                             {
12977                                                               /* 33222222222211111111110000000000
12978                                                                  10987654321098765432109876543210
12979                                                                  001001x100011xxx01xxxx0xxxxxxxxx
12980                                                                  brkn.  */
12981                                                               return 1307;
12982                                                             }
12983                                                         }
12984                                                     }
12985                                                   else
12986                                                     {
12987                                                       if (((word >> 4) & 0x1) == 0)
12988                                                         {
12989                                                           /* 33222222222211111111110000000000
12990                                                              10987654321098765432109876543210
12991                                                              001001x1000xxxxx01xxxx1xxxx0xxxx
12992                                                              eor.  */
12993                                                           return 1376;
12994                                                         }
12995                                                       else
12996                                                         {
12997                                                           /* 33222222222211111111110000000000
12998                                                              10987654321098765432109876543210
12999                                                              001001x1000xxxxx01xxxx1xxxx1xxxx
13000                                                              sel.  */
13001                                                           return 1825;
13002                                                         }
13003                                                     }
13004                                                 }
13005                                               else
13006                                                 {
13007                                                   if (((word >> 13) & 0x1) == 0)
13008                                                     {
13009                                                       /* 33222222222211111111110000000000
13010                                                          10987654321098765432109876543210
13011                                                          101001x1000xxxxx010xxxxxxxxxxxxx
13012                                                          ld1sh.  */
13013                                                       return 1575;
13014                                                     }
13015                                                   else
13016                                                     {
13017                                                       /* 33222222222211111111110000000000
13018                                                          10987654321098765432109876543210
13019                                                          101001x1000xxxxx011xxxxxxxxxxxxx
13020                                                          ldff1sh.  */
13021                                                       return 1675;
13022                                                     }
13023                                                 }
13024                                             }
13025                                           else
13026                                             {
13027                                               if (((word >> 31) & 0x1) == 0)
13028                                                 {
13029                                                   if (((word >> 9) & 0x1) == 0)
13030                                                     {
13031                                                       if (((word >> 20) & 0x1) == 0)
13032                                                         {
13033                                                           if (((word >> 4) & 0x1) == 0)
13034                                                             {
13035                                                               /* 33222222222211111111110000000000
13036                                                                  10987654321098765432109876543210
13037                                                                  001001x11000xxxx01xxxx0xxxx0xxxx
13038                                                                  orr.  */
13039                                                               return 1761;
13040                                                             }
13041                                                           else
13042                                                             {
13043                                                               /* 33222222222211111111110000000000
13044                                                                  10987654321098765432109876543210
13045                                                                  001001x11000xxxx01xxxx0xxxx1xxxx
13046                                                                  orn.  */
13047                                                               return 1756;
13048                                                             }
13049                                                         }
13050                                                       else
13051                                                         {
13052                                                           /* 33222222222211111111110000000000
13053                                                              10987654321098765432109876543210
13054                                                              001001x11001xxxx01xxxx0xxxxxxxxx
13055                                                              brkb.  */
13056                                                           return 1305;
13057                                                         }
13058                                                     }
13059                                                   else
13060                                                     {
13061                                                       if (((word >> 4) & 0x1) == 0)
13062                                                         {
13063                                                           /* 33222222222211111111110000000000
13064                                                              10987654321098765432109876543210
13065                                                              001001x1100xxxxx01xxxx1xxxx0xxxx
13066                                                              nor.  */
13067                                                           return 1753;
13068                                                         }
13069                                                       else
13070                                                         {
13071                                                           /* 33222222222211111111110000000000
13072                                                              10987654321098765432109876543210
13073                                                              001001x1100xxxxx01xxxx1xxxx1xxxx
13074                                                              nand.  */
13075                                                           return 1750;
13076                                                         }
13077                                                     }
13078                                                 }
13079                                               else
13080                                                 {
13081                                                   if (((word >> 13) & 0x1) == 0)
13082                                                     {
13083                                                       /* 33222222222211111111110000000000
13084                                                          10987654321098765432109876543210
13085                                                          101001x1100xxxxx010xxxxxxxxxxxxx
13086                                                          ld1sb.  */
13087                                                       return 1563;
13088                                                     }
13089                                                   else
13090                                                     {
13091                                                       /* 33222222222211111111110000000000
13092                                                          10987654321098765432109876543210
13093                                                          101001x1100xxxxx011xxxxxxxxxxxxx
13094                                                          ldff1sb.  */
13095                                                       return 1663;
13096                                                     }
13097                                                 }
13098                                             }
13099                                         }
13100                                       else
13101                                         {
13102                                           if (((word >> 23) & 0x1) == 0)
13103                                             {
13104                                               if (((word >> 31) & 0x1) == 0)
13105                                                 {
13106                                                   if (((word >> 4) & 0x1) == 0)
13107                                                     {
13108                                                       if (((word >> 9) & 0x1) == 0)
13109                                                         {
13110                                                           if (((word >> 20) & 0x1) == 0)
13111                                                             {
13112                                                               /* 33222222222211111111110000000000
13113                                                                  10987654321098765432109876543210
13114                                                                  001001x10100xxxx01xxxx0xxxx0xxxx
13115                                                                  ands.  */
13116                                                               return 1290;
13117                                                             }
13118                                                           else
13119                                                             {
13120                                                               if (((word >> 19) & 0x1) == 0)
13121                                                                 {
13122                                                                   /* 33222222222211111111110000000000
13123                                                                      10987654321098765432109876543210
13124                                                                      001001x101010xxx01xxxx0xxxx0xxxx
13125                                                                      brkas.  */
13126                                                                   return 1304;
13127                                                                 }
13128                                                               else
13129                                                                 {
13130                                                                   /* 33222222222211111111110000000000
13131                                                                      10987654321098765432109876543210
13132                                                                      001001x101011xxx01xxxx0xxxx0xxxx
13133                                                                      brkns.  */
13134                                                                   return 1308;
13135                                                                 }
13136                                                             }
13137                                                         }
13138                                                       else
13139                                                         {
13140                                                           /* 33222222222211111111110000000000
13141                                                              10987654321098765432109876543210
13142                                                              001001x1010xxxxx01xxxx1xxxx0xxxx
13143                                                              eors.  */
13144                                                           return 1377;
13145                                                         }
13146                                                     }
13147                                                   else
13148                                                     {
13149                                                       /* 33222222222211111111110000000000
13150                                                          10987654321098765432109876543210
13151                                                          001001x1010xxxxx01xxxxxxxxx1xxxx
13152                                                          bics.  */
13153                                                       return 1302;
13154                                                     }
13155                                                 }
13156                                               else
13157                                                 {
13158                                                   if (((word >> 13) & 0x1) == 0)
13159                                                     {
13160                                                       /* 33222222222211111111110000000000
13161                                                          10987654321098765432109876543210
13162                                                          101001x1010xxxxx010xxxxxxxxxxxxx
13163                                                          ld1w.  */
13164                                                       return 1594;
13165                                                     }
13166                                                   else
13167                                                     {
13168                                                       /* 33222222222211111111110000000000
13169                                                          10987654321098765432109876543210
13170                                                          101001x1010xxxxx011xxxxxxxxxxxxx
13171                                                          ldff1w.  */
13172                                                       return 1694;
13173                                                     }
13174                                                 }
13175                                             }
13176                                           else
13177                                             {
13178                                               if (((word >> 31) & 0x1) == 0)
13179                                                 {
13180                                                   if (((word >> 4) & 0x1) == 0)
13181                                                     {
13182                                                       if (((word >> 9) & 0x1) == 0)
13183                                                         {
13184                                                           if (((word >> 20) & 0x1) == 0)
13185                                                             {
13186                                                               /* 33222222222211111111110000000000
13187                                                                  10987654321098765432109876543210
13188                                                                  001001x11100xxxx01xxxx0xxxx0xxxx
13189                                                                  orrs.  */
13190                                                               return 1762;
13191                                                             }
13192                                                           else
13193                                                             {
13194                                                               /* 33222222222211111111110000000000
13195                                                                  10987654321098765432109876543210
13196                                                                  001001x11101xxxx01xxxx0xxxx0xxxx
13197                                                                  brkbs.  */
13198                                                               return 1306;
13199                                                             }
13200                                                         }
13201                                                       else
13202                                                         {
13203                                                           /* 33222222222211111111110000000000
13204                                                              10987654321098765432109876543210
13205                                                              001001x1110xxxxx01xxxx1xxxx0xxxx
13206                                                              nors.  */
13207                                                           return 1754;
13208                                                         }
13209                                                     }
13210                                                   else
13211                                                     {
13212                                                       if (((word >> 9) & 0x1) == 0)
13213                                                         {
13214                                                           /* 33222222222211111111110000000000
13215                                                              10987654321098765432109876543210
13216                                                              001001x1110xxxxx01xxxx0xxxx1xxxx
13217                                                              orns.  */
13218                                                           return 1757;
13219                                                         }
13220                                                       else
13221                                                         {
13222                                                           /* 33222222222211111111110000000000
13223                                                              10987654321098765432109876543210
13224                                                              001001x1110xxxxx01xxxx1xxxx1xxxx
13225                                                              nands.  */
13226                                                           return 1751;
13227                                                         }
13228                                                     }
13229                                                 }
13230                                               else
13231                                                 {
13232                                                   if (((word >> 13) & 0x1) == 0)
13233                                                     {
13234                                                       /* 33222222222211111111110000000000
13235                                                          10987654321098765432109876543210
13236                                                          101001x1110xxxxx010xxxxxxxxxxxxx
13237                                                          ld1sb.  */
13238                                                       return 1565;
13239                                                     }
13240                                                   else
13241                                                     {
13242                                                       /* 33222222222211111111110000000000
13243                                                          10987654321098765432109876543210
13244                                                          101001x1110xxxxx011xxxxxxxxxxxxx
13245                                                          ldff1sb.  */
13246                                                       return 1667;
13247                                                     }
13248                                                 }
13249                                             }
13250                                         }
13251                                     }
13252                                   else
13253                                     {
13254                                       if (((word >> 13) & 0x1) == 0)
13255                                         {
13256                                           if (((word >> 22) & 0x1) == 0)
13257                                             {
13258                                               if (((word >> 23) & 0x1) == 0)
13259                                                 {
13260                                                   /* 33222222222211111111110000000000
13261                                                      10987654321098765432109876543210
13262                                                      x01001x1001xxxxx010xxxxxxxxxxxxx
13263                                                      ld1sh.  */
13264                                                   return 1576;
13265                                                 }
13266                                               else
13267                                                 {
13268                                                   /* 33222222222211111111110000000000
13269                                                      10987654321098765432109876543210
13270                                                      x01001x1101xxxxx010xxxxxxxxxxxxx
13271                                                      ld1sb.  */
13272                                                   return 1564;
13273                                                 }
13274                                             }
13275                                           else
13276                                             {
13277                                               if (((word >> 23) & 0x1) == 0)
13278                                                 {
13279                                                   /* 33222222222211111111110000000000
13280                                                      10987654321098765432109876543210
13281                                                      x01001x1011xxxxx010xxxxxxxxxxxxx
13282                                                      ld1w.  */
13283                                                   return 1595;
13284                                                 }
13285                                               else
13286                                                 {
13287                                                   /* 33222222222211111111110000000000
13288                                                      10987654321098765432109876543210
13289                                                      x01001x1111xxxxx010xxxxxxxxxxxxx
13290                                                      ld1d.  */
13291                                                   return 1517;
13292                                                 }
13293                                             }
13294                                         }
13295                                       else
13296                                         {
13297                                           if (((word >> 22) & 0x1) == 0)
13298                                             {
13299                                               if (((word >> 23) & 0x1) == 0)
13300                                                 {
13301                                                   /* 33222222222211111111110000000000
13302                                                      10987654321098765432109876543210
13303                                                      x01001x1001xxxxx011xxxxxxxxxxxxx
13304                                                      ldff1sh.  */
13305                                                   return 1677;
13306                                                 }
13307                                               else
13308                                                 {
13309                                                   /* 33222222222211111111110000000000
13310                                                      10987654321098765432109876543210
13311                                                      x01001x1101xxxxx011xxxxxxxxxxxxx
13312                                                      ldff1sb.  */
13313                                                   return 1665;
13314                                                 }
13315                                             }
13316                                           else
13317                                             {
13318                                               if (((word >> 23) & 0x1) == 0)
13319                                                 {
13320                                                   /* 33222222222211111111110000000000
13321                                                      10987654321098765432109876543210
13322                                                      x01001x1011xxxxx011xxxxxxxxxxxxx
13323                                                      ldff1w.  */
13324                                                   return 1696;
13325                                                 }
13326                                               else
13327                                                 {
13328                                                   /* 33222222222211111111110000000000
13329                                                      10987654321098765432109876543210
13330                                                      x01001x1111xxxxx011xxxxxxxxxxxxx
13331                                                      ldff1d.  */
13332                                                   return 1641;
13333                                                 }
13334                                             }
13335                                         }
13336                                     }
13337                                 }
13338                               else
13339                                 {
13340                                   if (((word >> 13) & 0x1) == 0)
13341                                     {
13342                                       if (((word >> 31) & 0x1) == 0)
13343                                         {
13344                                           if (((word >> 21) & 0x1) == 0)
13345                                             {
13346                                               if (((word >> 4) & 0x1) == 0)
13347                                                 {
13348                                                   /* 33222222222211111111110000000000
13349                                                      10987654321098765432109876543210
13350                                                      011001x1xx0xxxxx010xxxxxxxx0xxxx
13351                                                      fcmge.  */
13352                                                   return 1396;
13353                                                 }
13354                                               else
13355                                                 {
13356                                                   /* 33222222222211111111110000000000
13357                                                      10987654321098765432109876543210
13358                                                      011001x1xx0xxxxx010xxxxxxxx1xxxx
13359                                                      fcmgt.  */
13360                                                   return 1398;
13361                                                 }
13362                                             }
13363                                           else
13364                                             {
13365                                               /* 33222222222211111111110000000000
13366                                                  10987654321098765432109876543210
13367                                                  011001x1xx1xxxxx010xxxxxxxxxxxxx
13368                                                  fnmla.  */
13369                                               return 1460;
13370                                             }
13371                                         }
13372                                       else
13373                                         {
13374                                           if (((word >> 22) & 0x1) == 0)
13375                                             {
13376                                               /* 33222222222211111111110000000000
13377                                                  10987654321098765432109876543210
13378                                                  111001x1x0xxxxxx010xxxxxxxxxxxxx
13379                                                  str.  */
13380                                               return 1946;
13381                                             }
13382                                           else
13383                                             {
13384                                               if (((word >> 21) & 0x1) == 0)
13385                                                 {
13386                                                   /* 33222222222211111111110000000000
13387                                                      10987654321098765432109876543210
13388                                                      111001x1x10xxxxx010xxxxxxxxxxxxx
13389                                                      st1w.  */
13390                                                   return 1905;
13391                                                 }
13392                                               else
13393                                                 {
13394                                                   if (((word >> 23) & 0x1) == 0)
13395                                                     {
13396                                                       /* 33222222222211111111110000000000
13397                                                          10987654321098765432109876543210
13398                                                          111001x1011xxxxx010xxxxxxxxxxxxx
13399                                                          st1w.  */
13400                                                       return 1907;
13401                                                     }
13402                                                   else
13403                                                     {
13404                                                       /* 33222222222211111111110000000000
13405                                                          10987654321098765432109876543210
13406                                                          111001x1111xxxxx010xxxxxxxxxxxxx
13407                                                          st1d.  */
13408                                                       return 1884;
13409                                                     }
13410                                                 }
13411                                             }
13412                                         }
13413                                     }
13414                                   else
13415                                     {
13416                                       if (((word >> 21) & 0x1) == 0)
13417                                         {
13418                                           if (((word >> 31) & 0x1) == 0)
13419                                             {
13420                                               if (((word >> 4) & 0x1) == 0)
13421                                                 {
13422                                                   /* 33222222222211111111110000000000
13423                                                      10987654321098765432109876543210
13424                                                      011001x1xx0xxxxx011xxxxxxxx0xxxx
13425                                                      fcmeq.  */
13426                                                   return 1394;
13427                                                 }
13428                                               else
13429                                                 {
13430                                                   /* 33222222222211111111110000000000
13431                                                      10987654321098765432109876543210
13432                                                      011001x1xx0xxxxx011xxxxxxxx1xxxx
13433                                                      fcmne.  */
13434                                                   return 1402;
13435                                                 }
13436                                             }
13437                                           else
13438                                             {
13439                                               if (((word >> 22) & 0x1) == 0)
13440                                                 {
13441                                                   if (((word >> 23) & 0x1) == 0)
13442                                                     {
13443                                                       /* 33222222222211111111110000000000
13444                                                          10987654321098765432109876543210
13445                                                          111001x1000xxxxx011xxxxxxxxxxxxx
13446                                                          stnt1w.  */
13447                                                       return 1943;
13448                                                     }
13449                                                   else
13450                                                     {
13451                                                       /* 33222222222211111111110000000000
13452                                                          10987654321098765432109876543210
13453                                                          111001x1100xxxxx011xxxxxxxxxxxxx
13454                                                          stnt1d.  */
13455                                                       return 1939;
13456                                                     }
13457                                                 }
13458                                               else
13459                                                 {
13460                                                   if (((word >> 23) & 0x1) == 0)
13461                                                     {
13462                                                       /* 33222222222211111111110000000000
13463                                                          10987654321098765432109876543210
13464                                                          111001x1010xxxxx011xxxxxxxxxxxxx
13465                                                          st3w.  */
13466                                                       return 1927;
13467                                                     }
13468                                                   else
13469                                                     {
13470                                                       /* 33222222222211111111110000000000
13471                                                          10987654321098765432109876543210
13472                                                          111001x1110xxxxx011xxxxxxxxxxxxx
13473                                                          st3d.  */
13474                                                       return 1923;
13475                                                     }
13476                                                 }
13477                                             }
13478                                         }
13479                                       else
13480                                         {
13481                                           if (((word >> 31) & 0x1) == 0)
13482                                             {
13483                                               /* 33222222222211111111110000000000
13484                                                  10987654321098765432109876543210
13485                                                  011001x1xx1xxxxx011xxxxxxxxxxxxx
13486                                                  fnmls.  */
13487                                               return 1461;
13488                                             }
13489                                           else
13490                                             {
13491                                               if (((word >> 22) & 0x1) == 0)
13492                                                 {
13493                                                   if (((word >> 23) & 0x1) == 0)
13494                                                     {
13495                                                       /* 33222222222211111111110000000000
13496                                                          10987654321098765432109876543210
13497                                                          111001x1001xxxxx011xxxxxxxxxxxxx
13498                                                          st2w.  */
13499                                                       return 1919;
13500                                                     }
13501                                                   else
13502                                                     {
13503                                                       /* 33222222222211111111110000000000
13504                                                          10987654321098765432109876543210
13505                                                          111001x1101xxxxx011xxxxxxxxxxxxx
13506                                                          st2d.  */
13507                                                       return 1915;
13508                                                     }
13509                                                 }
13510                                               else
13511                                                 {
13512                                                   if (((word >> 23) & 0x1) == 0)
13513                                                     {
13514                                                       /* 33222222222211111111110000000000
13515                                                          10987654321098765432109876543210
13516                                                          111001x1011xxxxx011xxxxxxxxxxxxx
13517                                                          st4w.  */
13518                                                       return 1935;
13519                                                     }
13520                                                   else
13521                                                     {
13522                                                       /* 33222222222211111111110000000000
13523                                                          10987654321098765432109876543210
13524                                                          111001x1111xxxxx011xxxxxxxxxxxxx
13525                                                          st4d.  */
13526                                                       return 1931;
13527                                                     }
13528                                                 }
13529                                             }
13530                                         }
13531                                     }
13532                                 }
13533                             }
13534                         }
13535                       else
13536                         {
13537                           if (((word >> 21) & 0x1) == 0)
13538                             {
13539                               if (((word >> 30) & 0x1) == 0)
13540                                 {
13541                                   if (((word >> 14) & 0x1) == 0)
13542                                     {
13543                                       if (((word >> 13) & 0x1) == 0)
13544                                         {
13545                                           if (((word >> 4) & 0x1) == 0)
13546                                             {
13547                                               /* 33222222222211111111110000000000
13548                                                  10987654321098765432109876543210
13549                                                  x01001x1xx0xxxxx100xxxxxxxx0xxxx
13550                                                  cmpeq.  */
13551                                               return 1323;
13552                                             }
13553                                           else
13554                                             {
13555                                               /* 33222222222211111111110000000000
13556                                                  10987654321098765432109876543210
13557                                                  x01001x1xx0xxxxx100xxxxxxxx1xxxx
13558                                                  cmpne.  */
13559                                               return 1346;
13560                                             }
13561                                         }
13562                                       else
13563                                         {
13564                                           if (((word >> 20) & 0x1) == 0)
13565                                             {
13566                                               if (((word >> 22) & 0x1) == 0)
13567                                                 {
13568                                                   if (((word >> 23) & 0x1) == 0)
13569                                                     {
13570                                                       /* 33222222222211111111110000000000
13571                                                          10987654321098765432109876543210
13572                                                          x01001x10000xxxx101xxxxxxxxxxxxx
13573                                                          ld1sh.  */
13574                                                       return 1582;
13575                                                     }
13576                                                   else
13577                                                     {
13578                                                       /* 33222222222211111111110000000000
13579                                                          10987654321098765432109876543210
13580                                                          x01001x11000xxxx101xxxxxxxxxxxxx
13581                                                          ld1sb.  */
13582                                                       return 1569;
13583                                                     }
13584                                                 }
13585                                               else
13586                                                 {
13587                                                   if (((word >> 23) & 0x1) == 0)
13588                                                     {
13589                                                       /* 33222222222211111111110000000000
13590                                                          10987654321098765432109876543210
13591                                                          x01001x10100xxxx101xxxxxxxxxxxxx
13592                                                          ld1w.  */
13593                                                       return 1601;
13594                                                     }
13595                                                   else
13596                                                     {
13597                                                       /* 33222222222211111111110000000000
13598                                                          10987654321098765432109876543210
13599                                                          x01001x11100xxxx101xxxxxxxxxxxxx
13600                                                          ld1sb.  */
13601                                                       return 1571;
13602                                                     }
13603                                                 }
13604                                             }
13605                                           else
13606                                             {
13607                                               if (((word >> 22) & 0x1) == 0)
13608                                                 {
13609                                                   if (((word >> 23) & 0x1) == 0)
13610                                                     {
13611                                                       /* 33222222222211111111110000000000
13612                                                          10987654321098765432109876543210
13613                                                          x01001x10001xxxx101xxxxxxxxxxxxx
13614                                                          ldnf1sh.  */
13615                                                       return 1715;
13616                                                     }
13617                                                   else
13618                                                     {
13619                                                       /* 33222222222211111111110000000000
13620                                                          10987654321098765432109876543210
13621                                                          x01001x11001xxxx101xxxxxxxxxxxxx
13622                                                          ldnf1sb.  */
13623                                                       return 1712;
13624                                                     }
13625                                                 }
13626                                               else
13627                                                 {
13628                                                   if (((word >> 23) & 0x1) == 0)
13629                                                     {
13630                                                       /* 33222222222211111111110000000000
13631                                                          10987654321098765432109876543210
13632                                                          x01001x10101xxxx101xxxxxxxxxxxxx
13633                                                          ldnf1w.  */
13634                                                       return 1718;
13635                                                     }
13636                                                   else
13637                                                     {
13638                                                       /* 33222222222211111111110000000000
13639                                                          10987654321098765432109876543210
13640                                                          x01001x11101xxxx101xxxxxxxxxxxxx
13641                                                          ldnf1sb.  */
13642                                                       return 1714;
13643                                                     }
13644                                                 }
13645                                             }
13646                                         }
13647                                     }
13648                                   else
13649                                     {
13650                                       if (((word >> 31) & 0x1) == 0)
13651                                         {
13652                                           if (((word >> 4) & 0x1) == 0)
13653                                             {
13654                                               if (((word >> 20) & 0x1) == 0)
13655                                                 {
13656                                                   if (((word >> 22) & 0x1) == 0)
13657                                                     {
13658                                                       /* 33222222222211111111110000000000
13659                                                          10987654321098765432109876543210
13660                                                          001001x1x000xxxx11xxxxxxxxx0xxxx
13661                                                          brkpa.  */
13662                                                       return 1309;
13663                                                     }
13664                                                   else
13665                                                     {
13666                                                       /* 33222222222211111111110000000000
13667                                                          10987654321098765432109876543210
13668                                                          001001x1x100xxxx11xxxxxxxxx0xxxx
13669                                                          brkpas.  */
13670                                                       return 1310;
13671                                                     }
13672                                                 }
13673                                               else
13674                                                 {
13675                                                   if (((word >> 16) & 0x1) == 0)
13676                                                     {
13677                                                       if (((word >> 19) & 0x1) == 0)
13678                                                         {
13679                                                           /* 33222222222211111111110000000000
13680                                                              10987654321098765432109876543210
13681                                                              001001x1xx010xx011xxxxxxxxx0xxxx
13682                                                              ptest.  */
13683                                                           return 1795;
13684                                                         }
13685                                                       else
13686                                                         {
13687                                                           if (((word >> 10) & 0x1) == 0)
13688                                                             {
13689                                                               if (((word >> 12) & 0x1) == 0)
13690                                                                 {
13691                                                                   if (((word >> 13) & 0x1) == 0)
13692                                                                     {
13693                                                                       /* 33222222222211111111110000000000
13694                                                                          10987654321098765432109876543210
13695                                                                          001001x1xx011xx01100x0xxxxx0xxxx
13696                                                                          pfirst.  */
13697                                                                       return 1765;
13698                                                                     }
13699                                                                   else
13700                                                                     {
13701                                                                       /* 33222222222211111111110000000000
13702                                                                          10987654321098765432109876543210
13703                                                                          001001x1xx011xx01110x0xxxxx0xxxx
13704                                                                          ptrue.  */
13705                                                                       return 1796;
13706                                                                     }
13707                                                                 }
13708                                                               else
13709                                                                 {
13710                                                                   if (((word >> 22) & 0x1) == 0)
13711                                                                     {
13712                                                                       /* 33222222222211111111110000000000
13713                                                                          10987654321098765432109876543210
13714                                                                          001001x1x0011xx011x1x0xxxxx0xxxx
13715                                                                          rdffr.  */
13716                                                                       return 1802;
13717                                                                     }
13718                                                                   else
13719                                                                     {
13720                                                                       /* 33222222222211111111110000000000
13721                                                                          10987654321098765432109876543210
13722                                                                          001001x1x1011xx011x1x0xxxxx0xxxx
13723                                                                          rdffrs.  */
13724                                                                       return 1803;
13725                                                                     }
13726                                                                 }
13727                                                             }
13728                                                           else
13729                                                             {
13730                                                               /* 33222222222211111111110000000000
13731                                                                  10987654321098765432109876543210
13732                                                                  001001x1xx011xx011xxx1xxxxx0xxxx
13733                                                                  pfalse.  */
13734                                                               return 1764;
13735                                                             }
13736                                                         }
13737                                                     }
13738                                                   else
13739                                                     {
13740                                                       if (((word >> 10) & 0x1) == 0)
13741                                                         {
13742                                                           if (((word >> 12) & 0x1) == 0)
13743                                                             {
13744                                                               /* 33222222222211111111110000000000
13745                                                                  10987654321098765432109876543210
13746                                                                  001001x1xx01xxx111x0x0xxxxx0xxxx
13747                                                                  ptrues.  */
13748                                                               return 1797;
13749                                                             }
13750                                                           else
13751                                                             {
13752                                                               /* 33222222222211111111110000000000
13753                                                                  10987654321098765432109876543210
13754                                                                  001001x1xx01xxx111x1x0xxxxx0xxxx
13755                                                                  rdffr.  */
13756                                                               return 1801;
13757                                                             }
13758                                                         }
13759                                                       else
13760                                                         {
13761                                                           /* 33222222222211111111110000000000
13762                                                              10987654321098765432109876543210
13763                                                              001001x1xx01xxx111xxx1xxxxx0xxxx
13764                                                              pnext.  */
13765                                                           return 1766;
13766                                                         }
13767                                                     }
13768                                                 }
13769                                             }
13770                                           else
13771                                             {
13772                                               if (((word >> 22) & 0x1) == 0)
13773                                                 {
13774                                                   /* 33222222222211111111110000000000
13775                                                      10987654321098765432109876543210
13776                                                      001001x1x00xxxxx11xxxxxxxxx1xxxx
13777                                                      brkpb.  */
13778                                                   return 1311;
13779                                                 }
13780                                               else
13781                                                 {
13782                                                   /* 33222222222211111111110000000000
13783                                                      10987654321098765432109876543210
13784                                                      001001x1x10xxxxx11xxxxxxxxx1xxxx
13785                                                      brkpbs.  */
13786                                                   return 1312;
13787                                                 }
13788                                             }
13789                                         }
13790                                       else
13791                                         {
13792                                           if (((word >> 13) & 0x1) == 0)
13793                                             {
13794                                               if (((word >> 22) & 0x1) == 0)
13795                                                 {
13796                                                   if (((word >> 23) & 0x1) == 0)
13797                                                     {
13798                                                       /* 33222222222211111111110000000000
13799                                                          10987654321098765432109876543210
13800                                                          101001x1000xxxxx110xxxxxxxxxxxxx
13801                                                          ldnt1w.  */
13802                                                       return 1726;
13803                                                     }
13804                                                   else
13805                                                     {
13806                                                       /* 33222222222211111111110000000000
13807                                                          10987654321098765432109876543210
13808                                                          101001x1100xxxxx110xxxxxxxxxxxxx
13809                                                          ldnt1d.  */
13810                                                       return 1722;
13811                                                     }
13812                                                 }
13813                                               else
13814                                                 {
13815                                                   if (((word >> 23) & 0x1) == 0)
13816                                                     {
13817                                                       /* 33222222222211111111110000000000
13818                                                          10987654321098765432109876543210
13819                                                          101001x1010xxxxx110xxxxxxxxxxxxx
13820                                                          ld3w.  */
13821                                                       return 1618;
13822                                                     }
13823                                                   else
13824                                                     {
13825                                                       /* 33222222222211111111110000000000
13826                                                          10987654321098765432109876543210
13827                                                          101001x1110xxxxx110xxxxxxxxxxxxx
13828                                                          ld3d.  */
13829                                                       return 1614;
13830                                                     }
13831                                                 }
13832                                             }
13833                                           else
13834                                             {
13835                                               if (((word >> 22) & 0x1) == 0)
13836                                                 {
13837                                                   if (((word >> 23) & 0x1) == 0)
13838                                                     {
13839                                                       /* 33222222222211111111110000000000
13840                                                          10987654321098765432109876543210
13841                                                          101001x1000xxxxx111xxxxxxxxxxxxx
13842                                                          ldnt1w.  */
13843                                                       return 1727;
13844                                                     }
13845                                                   else
13846                                                     {
13847                                                       /* 33222222222211111111110000000000
13848                                                          10987654321098765432109876543210
13849                                                          101001x1100xxxxx111xxxxxxxxxxxxx
13850                                                          ldnt1d.  */
13851                                                       return 1723;
13852                                                     }
13853                                                 }
13854                                               else
13855                                                 {
13856                                                   if (((word >> 23) & 0x1) == 0)
13857                                                     {
13858                                                       /* 33222222222211111111110000000000
13859                                                          10987654321098765432109876543210
13860                                                          101001x1010xxxxx111xxxxxxxxxxxxx
13861                                                          ld3w.  */
13862                                                       return 1619;
13863                                                     }
13864                                                   else
13865                                                     {
13866                                                       /* 33222222222211111111110000000000
13867                                                          10987654321098765432109876543210
13868                                                          101001x1110xxxxx111xxxxxxxxxxxxx
13869                                                          ld3d.  */
13870                                                       return 1615;
13871                                                     }
13872                                                 }
13873                                             }
13874                                         }
13875                                     }
13876                                 }
13877                               else
13878                                 {
13879                                   if (((word >> 13) & 0x1) == 0)
13880                                     {
13881                                       if (((word >> 31) & 0x1) == 0)
13882                                         {
13883                                           if (((word >> 14) & 0x1) == 0)
13884                                             {
13885                                               if (((word >> 19) & 0x1) == 0)
13886                                                 {
13887                                                   if (((word >> 20) & 0x1) == 0)
13888                                                     {
13889                                                       if (((word >> 16) & 0x1) == 0)
13890                                                         {
13891                                                           if (((word >> 17) & 0x1) == 0)
13892                                                             {
13893                                                               if (((word >> 18) & 0x1) == 0)
13894                                                                 {
13895                                                                   /* 33222222222211111111110000000000
13896                                                                      10987654321098765432109876543210
13897                                                                      011001x1xx000000100xxxxxxxxxxxxx
13898                                                                      fadd.  */
13899                                                                   return 1385;
13900                                                                 }
13901                                                               else
13902                                                                 {
13903                                                                   /* 33222222222211111111110000000000
13904                                                                      10987654321098765432109876543210
13905                                                                      011001x1xx000100100xxxxxxxxxxxxx
13906                                                                      fmaxnm.  */
13907                                                                   return 1432;
13908                                                                 }
13909                                                             }
13910                                                           else
13911                                                             {
13912                                                               if (((word >> 18) & 0x1) == 0)
13913                                                                 {
13914                                                                   /* 33222222222211111111110000000000
13915                                                                      10987654321098765432109876543210
13916                                                                      011001x1xx000010100xxxxxxxxxxxxx
13917                                                                      fmul.  */
13918                                                                   return 1452;
13919                                                                 }
13920                                                               else
13921                                                                 {
13922                                                                   /* 33222222222211111111110000000000
13923                                                                      10987654321098765432109876543210
13924                                                                      011001x1xx000110100xxxxxxxxxxxxx
13925                                                                      fmax.  */
13926                                                                   return 1430;
13927                                                                 }
13928                                                             }
13929                                                         }
13930                                                       else
13931                                                         {
13932                                                           if (((word >> 17) & 0x1) == 0)
13933                                                             {
13934                                                               if (((word >> 18) & 0x1) == 0)
13935                                                                 {
13936                                                                   /* 33222222222211111111110000000000
13937                                                                      10987654321098765432109876543210
13938                                                                      011001x1xx000001100xxxxxxxxxxxxx
13939                                                                      fsub.  */
13940                                                                   return 1478;
13941                                                                 }
13942                                                               else
13943                                                                 {
13944                                                                   /* 33222222222211111111110000000000
13945                                                                      10987654321098765432109876543210
13946                                                                      011001x1xx000101100xxxxxxxxxxxxx
13947                                                                      fminnm.  */
13948                                                                   return 1438;
13949                                                                 }
13950                                                             }
13951                                                           else
13952                                                             {
13953                                                               if (((word >> 18) & 0x1) == 0)
13954                                                                 {
13955                                                                   /* 33222222222211111111110000000000
13956                                                                      10987654321098765432109876543210
13957                                                                      011001x1xx000011100xxxxxxxxxxxxx
13958                                                                      fsubr.  */
13959                                                                   return 1480;
13960                                                                 }
13961                                                               else
13962                                                                 {
13963                                                                   /* 33222222222211111111110000000000
13964                                                                      10987654321098765432109876543210
13965                                                                      011001x1xx000111100xxxxxxxxxxxxx
13966                                                                      fmin.  */
13967                                                                   return 1436;
13968                                                                 }
13969                                                             }
13970                                                         }
13971                                                     }
13972                                                   else
13973                                                     {
13974                                                       /* 33222222222211111111110000000000
13975                                                          10987654321098765432109876543210
13976                                                          011001x1xx010xxx100xxxxxxxxxxxxx
13977                                                          ftmad.  */
13978                                                       return 1482;
13979                                                     }
13980                                                 }
13981                                               else
13982                                                 {
13983                                                   if (((word >> 16) & 0x1) == 0)
13984                                                     {
13985                                                       if (((word >> 17) & 0x1) == 0)
13986                                                         {
13987                                                           if (((word >> 18) & 0x1) == 0)
13988                                                             {
13989                                                               if (((word >> 20) & 0x1) == 0)
13990                                                                 {
13991                                                                   /* 33222222222211111111110000000000
13992                                                                      10987654321098765432109876543210
13993                                                                      011001x1xx001000100xxxxxxxxxxxxx
13994                                                                      fabd.  */
13995                                                                   return 1380;
13996                                                                 }
13997                                                               else
13998                                                                 {
13999                                                                   /* 33222222222211111111110000000000
14000                                                                      10987654321098765432109876543210
14001                                                                      011001x1xx011000100xxxxxxxxxxxxx
14002                                                                      fadd.  */
14003                                                                   return 1386;
14004                                                                 }
14005                                                             }
14006                                                           else
14007                                                             {
14008                                                               if (((word >> 20) & 0x1) == 0)
14009                                                                 {
14010                                                                   /* 33222222222211111111110000000000
14011                                                                      10987654321098765432109876543210
14012                                                                      011001x1xx001100100xxxxxxxxxxxxx
14013                                                                      fdivr.  */
14014                                                                   return 1426;
14015                                                                 }
14016                                                               else
14017                                                                 {
14018                                                                   /* 33222222222211111111110000000000
14019                                                                      10987654321098765432109876543210
14020                                                                      011001x1xx011100100xxxxxxxxxxxxx
14021                                                                      fmaxnm.  */
14022                                                                   return 1433;
14023                                                                 }
14024                                                             }
14025                                                         }
14026                                                       else
14027                                                         {
14028                                                           if (((word >> 18) & 0x1) == 0)
14029                                                             {
14030                                                               if (((word >> 20) & 0x1) == 0)
14031                                                                 {
14032                                                                   /* 33222222222211111111110000000000
14033                                                                      10987654321098765432109876543210
14034                                                                      011001x1xx001010100xxxxxxxxxxxxx
14035                                                                      fmulx.  */
14036                                                                   return 1457;
14037                                                                 }
14038                                                               else
14039                                                                 {
14040                                                                   /* 33222222222211111111110000000000
14041                                                                      10987654321098765432109876543210
14042                                                                      011001x1xx011010100xxxxxxxxxxxxx
14043                                                                      fmul.  */
14044                                                                   return 1453;
14045                                                                 }
14046                                                             }
14047                                                           else
14048                                                             {
14049                                                               /* 33222222222211111111110000000000
14050                                                                  10987654321098765432109876543210
14051                                                                  011001x1xx0x1110100xxxxxxxxxxxxx
14052                                                                  fmax.  */
14053                                                               return 1431;
14054                                                             }
14055                                                         }
14056                                                     }
14057                                                   else
14058                                                     {
14059                                                       if (((word >> 17) & 0x1) == 0)
14060                                                         {
14061                                                           if (((word >> 18) & 0x1) == 0)
14062                                                             {
14063                                                               if (((word >> 20) & 0x1) == 0)
14064                                                                 {
14065                                                                   /* 33222222222211111111110000000000
14066                                                                      10987654321098765432109876543210
14067                                                                      011001x1xx001001100xxxxxxxxxxxxx
14068                                                                      fscale.  */
14069                                                                   return 1475;
14070                                                                 }
14071                                                               else
14072                                                                 {
14073                                                                   /* 33222222222211111111110000000000
14074                                                                      10987654321098765432109876543210
14075                                                                      011001x1xx011001100xxxxxxxxxxxxx
14076                                                                      fsub.  */
14077                                                                   return 1479;
14078                                                                 }
14079                                                             }
14080                                                           else
14081                                                             {
14082                                                               if (((word >> 20) & 0x1) == 0)
14083                                                                 {
14084                                                                   /* 33222222222211111111110000000000
14085                                                                      10987654321098765432109876543210
14086                                                                      011001x1xx001101100xxxxxxxxxxxxx
14087                                                                      fdiv.  */
14088                                                                   return 1425;
14089                                                                 }
14090                                                               else
14091                                                                 {
14092                                                                   /* 33222222222211111111110000000000
14093                                                                      10987654321098765432109876543210
14094                                                                      011001x1xx011101100xxxxxxxxxxxxx
14095                                                                      fminnm.  */
14096                                                                   return 1439;
14097                                                                 }
14098                                                             }
14099                                                         }
14100                                                       else
14101                                                         {
14102                                                           if (((word >> 18) & 0x1) == 0)
14103                                                             {
14104                                                               /* 33222222222211111111110000000000
14105                                                                  10987654321098765432109876543210
14106                                                                  011001x1xx0x1011100xxxxxxxxxxxxx
14107                                                                  fsubr.  */
14108                                                               return 1481;
14109                                                             }
14110                                                           else
14111                                                             {
14112                                                               /* 33222222222211111111110000000000
14113                                                                  10987654321098765432109876543210
14114                                                                  011001x1xx0x1111100xxxxxxxxxxxxx
14115                                                                  fmin.  */
14116                                                               return 1437;
14117                                                             }
14118                                                         }
14119                                                     }
14120                                                 }
14121                                             }
14122                                           else
14123                                             {
14124                                               if (((word >> 4) & 0x1) == 0)
14125                                                 {
14126                                                   /* 33222222222211111111110000000000
14127                                                      10987654321098765432109876543210
14128                                                      011001x1xx0xxxxx110xxxxxxxx0xxxx
14129                                                      fcmuo.  */
14130                                                   return 1403;
14131                                                 }
14132                                               else
14133                                                 {
14134                                                   /* 33222222222211111111110000000000
14135                                                      10987654321098765432109876543210
14136                                                      011001x1xx0xxxxx110xxxxxxxx1xxxx
14137                                                      facge.  */
14138                                                   return 1382;
14139                                                 }
14140                                             }
14141                                         }
14142                                       else
14143                                         {
14144                                           if (((word >> 22) & 0x1) == 0)
14145                                             {
14146                                               if (((word >> 23) & 0x1) == 0)
14147                                                 {
14148                                                   /* 33222222222211111111110000000000
14149                                                      10987654321098765432109876543210
14150                                                      111001x1000xxxxx1x0xxxxxxxxxxxxx
14151                                                      st1w.  */
14152                                                   return 1901;
14153                                                 }
14154                                               else
14155                                                 {
14156                                                   /* 33222222222211111111110000000000
14157                                                      10987654321098765432109876543210
14158                                                      111001x1100xxxxx1x0xxxxxxxxxxxxx
14159                                                      st1d.  */
14160                                                   return 1880;
14161                                                 }
14162                                             }
14163                                           else
14164                                             {
14165                                               /* 33222222222211111111110000000000
14166                                                  10987654321098765432109876543210
14167                                                  111001x1x10xxxxx1x0xxxxxxxxxxxxx
14168                                                  st1w.  */
14169                                               return 1906;
14170                                             }
14171                                         }
14172                                     }
14173                                   else
14174                                     {
14175                                       if (((word >> 14) & 0x1) == 0)
14176                                         {
14177                                           if (((word >> 31) & 0x1) == 0)
14178                                             {
14179                                               if (((word >> 16) & 0x1) == 0)
14180                                                 {
14181                                                   if (((word >> 19) & 0x1) == 0)
14182                                                     {
14183                                                       if (((word >> 17) & 0x1) == 0)
14184                                                         {
14185                                                           if (((word >> 18) & 0x1) == 0)
14186                                                             {
14187                                                               if (((word >> 20) & 0x1) == 0)
14188                                                                 {
14189                                                                   /* 33222222222211111111110000000000
14190                                                                      10987654321098765432109876543210
14191                                                                      011001x1xx000000101xxxxxxxxxxxxx
14192                                                                      frintn.  */
14193                                                                   return 1469;
14194                                                                 }
14195                                                               else
14196                                                                 {
14197                                                                   /* 33222222222211111111110000000000
14198                                                                      10987654321098765432109876543210
14199                                                                      011001x1xx010000101xxxxxxxxxxxxx
14200                                                                      scvtf.  */
14201                                                                   return 1815;
14202                                                                 }
14203                                                             }
14204                                                           else
14205                                                             {
14206                                                               if (((word >> 20) & 0x1) == 0)
14207                                                                 {
14208                                                                   /* 33222222222211111111110000000000
14209                                                                      10987654321098765432109876543210
14210                                                                      011001x1xx000100101xxxxxxxxxxxxx
14211                                                                      frinta.  */
14212                                                                   return 1466;
14213                                                                 }
14214                                                               else
14215                                                                 {
14216                                                                   if (((word >> 22) & 0x1) == 0)
14217                                                                     {
14218                                                                       /* 33222222222211111111110000000000
14219                                                                          10987654321098765432109876543210
14220                                                                          011001x1x0010100101xxxxxxxxxxxxx
14221                                                                          scvtf.  */
14222                                                                       return 1814;
14223                                                                     }
14224                                                                   else
14225                                                                     {
14226                                                                       if (((word >> 23) & 0x1) == 0)
14227                                                                         {
14228                                                                           /* 33222222222211111111110000000000
14229                                                                              10987654321098765432109876543210
14230                                                                              011001x101010100101xxxxxxxxxxxxx
14231                                                                              scvtf.  */
14232                                                                           return 1813;
14233                                                                         }
14234                                                                       else
14235                                                                         {
14236                                                                           /* 33222222222211111111110000000000
14237                                                                              10987654321098765432109876543210
14238                                                                              011001x111010100101xxxxxxxxxxxxx
14239                                                                              scvtf.  */
14240                                                                           return 1817;
14241                                                                         }
14242                                                                     }
14243                                                                 }
14244                                                             }
14245                                                         }
14246                                                       else
14247                                                         {
14248                                                           if (((word >> 18) & 0x1) == 0)
14249                                                             {
14250                                                               if (((word >> 20) & 0x1) == 0)
14251                                                                 {
14252                                                                   /* 33222222222211111111110000000000
14253                                                                      10987654321098765432109876543210
14254                                                                      011001x1xx000010101xxxxxxxxxxxxx
14255                                                                      frintm.  */
14256                                                                   return 1468;
14257                                                                 }
14258                                                               else
14259                                                                 {
14260                                                                   /* 33222222222211111111110000000000
14261                                                                      10987654321098765432109876543210
14262                                                                      011001x1xx010010101xxxxxxxxxxxxx
14263                                                                      scvtf.  */
14264                                                                   return 1812;
14265                                                                 }
14266                                                             }
14267                                                           else
14268                                                             {
14269                                                               if (((word >> 20) & 0x1) == 0)
14270                                                                 {
14271                                                                   /* 33222222222211111111110000000000
14272                                                                      10987654321098765432109876543210
14273                                                                      011001x1xx000110101xxxxxxxxxxxxx
14274                                                                      frintx.  */
14275                                                                   return 1471;
14276                                                                 }
14277                                                               else
14278                                                                 {
14279                                                                   if (((word >> 23) & 0x1) == 0)
14280                                                                     {
14281                                                                       /* 33222222222211111111110000000000
14282                                                                          10987654321098765432109876543210
14283                                                                          011001x10x010110101xxxxxxxxxxxxx
14284                                                                          scvtf.  */
14285                                                                       return 1816;
14286                                                                     }
14287                                                                   else
14288                                                                     {
14289                                                                       /* 33222222222211111111110000000000
14290                                                                          10987654321098765432109876543210
14291                                                                          011001x11x010110101xxxxxxxxxxxxx
14292                                                                          scvtf.  */
14293                                                                       return 1818;
14294                                                                     }
14295                                                                 }
14296                                                             }
14297                                                         }
14298                                                     }
14299                                                   else
14300                                                     {
14301                                                       if (((word >> 20) & 0x1) == 0)
14302                                                         {
14303                                                           if (((word >> 17) & 0x1) == 0)
14304                                                             {
14305                                                               if (((word >> 18) & 0x1) == 0)
14306                                                                 {
14307                                                                   if (((word >> 22) & 0x1) == 0)
14308                                                                     {
14309                                                                       /* 33222222222211111111110000000000
14310                                                                          10987654321098765432109876543210
14311                                                                          011001x1x0001000101xxxxxxxxxxxxx
14312                                                                          fcvt.  */
14313                                                                       return 1405;
14314                                                                     }
14315                                                                   else
14316                                                                     {
14317                                                                       /* 33222222222211111111110000000000
14318                                                                          10987654321098765432109876543210
14319                                                                          011001x1x1001000101xxxxxxxxxxxxx
14320                                                                          fcvt.  */
14321                                                                       return 1407;
14322                                                                     }
14323                                                                 }
14324                                                               else
14325                                                                 {
14326                                                                   /* 33222222222211111111110000000000
14327                                                                      10987654321098765432109876543210
14328                                                                      011001x1xx001100101xxxxxxxxxxxxx
14329                                                                      frecpx.  */
14330                                                                   return 1465;
14331                                                                 }
14332                                                             }
14333                                                           else
14334                                                             {
14335                                                               if (((word >> 22) & 0x1) == 0)
14336                                                                 {
14337                                                                   if (((word >> 23) & 0x1) == 0)
14338                                                                     {
14339                                                                       /* 33222222222211111111110000000000
14340                                                                          10987654321098765432109876543210
14341                                                                          011001x100001x10101xxxxxxxxxxxxx
14342                                                                          fcvtx.  */
14343                                                                       return 2075;
14344                                                                     }
14345                                                                   else
14346                                                                     {
14347                                                                       /* 33222222222211111111110000000000
14348                                                                          10987654321098765432109876543210
14349                                                                          011001x110001x10101xxxxxxxxxxxxx
14350                                                                          bfcvt.  */
14351                                                                       return 2425;
14352                                                                     }
14353                                                                 }
14354                                                               else
14355                                                                 {
14356                                                                   /* 33222222222211111111110000000000
14357                                                                      10987654321098765432109876543210
14358                                                                      011001x1x1001x10101xxxxxxxxxxxxx
14359                                                                      fcvt.  */
14360                                                                   return 1409;
14361                                                                 }
14362                                                             }
14363                                                         }
14364                                                       else
14365                                                         {
14366                                                           if (((word >> 22) & 0x1) == 0)
14367                                                             {
14368                                                               if (((word >> 23) & 0x1) == 0)
14369                                                                 {
14370                                                                   /* 33222222222211111111110000000000
14371                                                                      10987654321098765432109876543210
14372                                                                      011001x100011xx0101xxxxxxxxxxxxx
14373                                                                      flogb.  */
14374                                                                   return 2077;
14375                                                                 }
14376                                                               else
14377                                                                 {
14378                                                                   /* 33222222222211111111110000000000
14379                                                                      10987654321098765432109876543210
14380                                                                      011001x110011xx0101xxxxxxxxxxxxx
14381                                                                      fcvtzs.  */
14382                                                                   return 1414;
14383                                                                 }
14384                                                             }
14385                                                           else
14386                                                             {
14387                                                               if (((word >> 17) & 0x1) == 0)
14388                                                                 {
14389                                                                   if (((word >> 18) & 0x1) == 0)
14390                                                                     {
14391                                                                       /* 33222222222211111111110000000000
14392                                                                          10987654321098765432109876543210
14393                                                                          011001x1x1011000101xxxxxxxxxxxxx
14394                                                                          fcvtzs.  */
14395                                                                       return 1415;
14396                                                                     }
14397                                                                   else
14398                                                                     {
14399                                                                       if (((word >> 23) & 0x1) == 0)
14400                                                                         {
14401                                                                           /* 33222222222211111111110000000000
14402                                                                              10987654321098765432109876543210
14403                                                                              011001x101011100101xxxxxxxxxxxxx
14404                                                                              fcvtzs.  */
14405                                                                           return 1412;
14406                                                                         }
14407                                                                       else
14408                                                                         {
14409                                                                           /* 33222222222211111111110000000000
14410                                                                              10987654321098765432109876543210
14411                                                                              011001x111011100101xxxxxxxxxxxxx
14412                                                                              fcvtzs.  */
14413                                                                           return 1416;
14414                                                                         }
14415                                                                     }
14416                                                                 }
14417                                                               else
14418                                                                 {
14419                                                                   if (((word >> 18) & 0x1) == 0)
14420                                                                     {
14421                                                                       /* 33222222222211111111110000000000
14422                                                                          10987654321098765432109876543210
14423                                                                          011001x1x1011010101xxxxxxxxxxxxx
14424                                                                          fcvtzs.  */
14425                                                                       return 1411;
14426                                                                     }
14427                                                                   else
14428                                                                     {
14429                                                                       if (((word >> 23) & 0x1) == 0)
14430                                                                         {
14431                                                                           /* 33222222222211111111110000000000
14432                                                                              10987654321098765432109876543210
14433                                                                              011001x101011110101xxxxxxxxxxxxx
14434                                                                              fcvtzs.  */
14435                                                                           return 1413;
14436                                                                         }
14437                                                                       else
14438                                                                         {
14439                                                                           /* 33222222222211111111110000000000
14440                                                                              10987654321098765432109876543210
14441                                                                              011001x111011110101xxxxxxxxxxxxx
14442                                                                              fcvtzs.  */
14443                                                                           return 1417;
14444                                                                         }
14445                                                                     }
14446                                                                 }
14447                                                             }
14448                                                         }
14449                                                     }
14450                                                 }
14451                                               else
14452                                                 {
14453                                                   if (((word >> 17) & 0x1) == 0)
14454                                                     {
14455                                                       if (((word >> 18) & 0x1) == 0)
14456                                                         {
14457                                                           if (((word >> 19) & 0x1) == 0)
14458                                                             {
14459                                                               if (((word >> 20) & 0x1) == 0)
14460                                                                 {
14461                                                                   /* 33222222222211111111110000000000
14462                                                                      10987654321098765432109876543210
14463                                                                      011001x1xx000001101xxxxxxxxxxxxx
14464                                                                      frintp.  */
14465                                                                   return 1470;
14466                                                                 }
14467                                                               else
14468                                                                 {
14469                                                                   /* 33222222222211111111110000000000
14470                                                                      10987654321098765432109876543210
14471                                                                      011001x1xx010001101xxxxxxxxxxxxx
14472                                                                      ucvtf.  */
14473                                                                   return 1967;
14474                                                                 }
14475                                                             }
14476                                                           else
14477                                                             {
14478                                                               if (((word >> 20) & 0x1) == 0)
14479                                                                 {
14480                                                                   if (((word >> 22) & 0x1) == 0)
14481                                                                     {
14482                                                                       /* 33222222222211111111110000000000
14483                                                                          10987654321098765432109876543210
14484                                                                          011001x1x0001001101xxxxxxxxxxxxx
14485                                                                          fcvt.  */
14486                                                                       return 1406;
14487                                                                     }
14488                                                                   else
14489                                                                     {
14490                                                                       /* 33222222222211111111110000000000
14491                                                                          10987654321098765432109876543210
14492                                                                          011001x1x1001001101xxxxxxxxxxxxx
14493                                                                          fcvt.  */
14494                                                                       return 1408;
14495                                                                     }
14496                                                                 }
14497                                                               else
14498                                                                 {
14499                                                                   /* 33222222222211111111110000000000
14500                                                                      10987654321098765432109876543210
14501                                                                      011001x1xx011001101xxxxxxxxxxxxx
14502                                                                      fcvtzu.  */
14503                                                                   return 1422;
14504                                                                 }
14505                                                             }
14506                                                         }
14507                                                       else
14508                                                         {
14509                                                           if (((word >> 19) & 0x1) == 0)
14510                                                             {
14511                                                               if (((word >> 22) & 0x1) == 0)
14512                                                                 {
14513                                                                   /* 33222222222211111111110000000000
14514                                                                      10987654321098765432109876543210
14515                                                                      011001x1x00x0101101xxxxxxxxxxxxx
14516                                                                      ucvtf.  */
14517                                                                   return 1966;
14518                                                                 }
14519                                                               else
14520                                                                 {
14521                                                                   if (((word >> 23) & 0x1) == 0)
14522                                                                     {
14523                                                                       /* 33222222222211111111110000000000
14524                                                                          10987654321098765432109876543210
14525                                                                          011001x1010x0101101xxxxxxxxxxxxx
14526                                                                          ucvtf.  */
14527                                                                       return 1965;
14528                                                                     }
14529                                                                   else
14530                                                                     {
14531                                                                       /* 33222222222211111111110000000000
14532                                                                          10987654321098765432109876543210
14533                                                                          011001x1110x0101101xxxxxxxxxxxxx
14534                                                                          ucvtf.  */
14535                                                                       return 1969;
14536                                                                     }
14537                                                                 }
14538                                                             }
14539                                                           else
14540                                                             {
14541                                                               if (((word >> 20) & 0x1) == 0)
14542                                                                 {
14543                                                                   /* 33222222222211111111110000000000
14544                                                                      10987654321098765432109876543210
14545                                                                      011001x1xx001101101xxxxxxxxxxxxx
14546                                                                      fsqrt.  */
14547                                                                   return 1476;
14548                                                                 }
14549                                                               else
14550                                                                 {
14551                                                                   if (((word >> 22) & 0x1) == 0)
14552                                                                     {
14553                                                                       /* 33222222222211111111110000000000
14554                                                                          10987654321098765432109876543210
14555                                                                          011001x1x0011101101xxxxxxxxxxxxx
14556                                                                          fcvtzu.  */
14557                                                                       return 1421;
14558                                                                     }
14559                                                                   else
14560                                                                     {
14561                                                                       if (((word >> 23) & 0x1) == 0)
14562                                                                         {
14563                                                                           /* 33222222222211111111110000000000
14564                                                                              10987654321098765432109876543210
14565                                                                              011001x101011101101xxxxxxxxxxxxx
14566                                                                              fcvtzu.  */
14567                                                                           return 1419;
14568                                                                         }
14569                                                                       else
14570                                                                         {
14571                                                                           /* 33222222222211111111110000000000
14572                                                                              10987654321098765432109876543210
14573                                                                              011001x111011101101xxxxxxxxxxxxx
14574                                                                              fcvtzu.  */
14575                                                                           return 1423;
14576                                                                         }
14577                                                                     }
14578                                                                 }
14579                                                             }
14580                                                         }
14581                                                     }
14582                                                   else
14583                                                     {
14584                                                       if (((word >> 18) & 0x1) == 0)
14585                                                         {
14586                                                           if (((word >> 19) & 0x1) == 0)
14587                                                             {
14588                                                               if (((word >> 20) & 0x1) == 0)
14589                                                                 {
14590                                                                   /* 33222222222211111111110000000000
14591                                                                      10987654321098765432109876543210
14592                                                                      011001x1xx000011101xxxxxxxxxxxxx
14593                                                                      frintz.  */
14594                                                                   return 1472;
14595                                                                 }
14596                                                               else
14597                                                                 {
14598                                                                   /* 33222222222211111111110000000000
14599                                                                      10987654321098765432109876543210
14600                                                                      011001x1xx010011101xxxxxxxxxxxxx
14601                                                                      ucvtf.  */
14602                                                                   return 1964;
14603                                                                 }
14604                                                             }
14605                                                           else
14606                                                             {
14607                                                               if (((word >> 20) & 0x1) == 0)
14608                                                                 {
14609                                                                   /* 33222222222211111111110000000000
14610                                                                      10987654321098765432109876543210
14611                                                                      011001x1xx001011101xxxxxxxxxxxxx
14612                                                                      fcvt.  */
14613                                                                   return 1410;
14614                                                                 }
14615                                                               else
14616                                                                 {
14617                                                                   /* 33222222222211111111110000000000
14618                                                                      10987654321098765432109876543210
14619                                                                      011001x1xx011011101xxxxxxxxxxxxx
14620                                                                      fcvtzu.  */
14621                                                                   return 1418;
14622                                                                 }
14623                                                             }
14624                                                         }
14625                                                       else
14626                                                         {
14627                                                           if (((word >> 19) & 0x1) == 0)
14628                                                             {
14629                                                               if (((word >> 20) & 0x1) == 0)
14630                                                                 {
14631                                                                   /* 33222222222211111111110000000000
14632                                                                      10987654321098765432109876543210
14633                                                                      011001x1xx000111101xxxxxxxxxxxxx
14634                                                                      frinti.  */
14635                                                                   return 1467;
14636                                                                 }
14637                                                               else
14638                                                                 {
14639                                                                   if (((word >> 23) & 0x1) == 0)
14640                                                                     {
14641                                                                       /* 33222222222211111111110000000000
14642                                                                          10987654321098765432109876543210
14643                                                                          011001x10x010111101xxxxxxxxxxxxx
14644                                                                          ucvtf.  */
14645                                                                       return 1968;
14646                                                                     }
14647                                                                   else
14648                                                                     {
14649                                                                       /* 33222222222211111111110000000000
14650                                                                          10987654321098765432109876543210
14651                                                                          011001x11x010111101xxxxxxxxxxxxx
14652                                                                          ucvtf.  */
14653                                                                       return 1970;
14654                                                                     }
14655                                                                 }
14656                                                             }
14657                                                           else
14658                                                             {
14659                                                               if (((word >> 23) & 0x1) == 0)
14660                                                                 {
14661                                                                   /* 33222222222211111111110000000000
14662                                                                      10987654321098765432109876543210
14663                                                                      011001x10x0x1111101xxxxxxxxxxxxx
14664                                                                      fcvtzu.  */
14665                                                                   return 1420;
14666                                                                 }
14667                                                               else
14668                                                                 {
14669                                                                   /* 33222222222211111111110000000000
14670                                                                      10987654321098765432109876543210
14671                                                                      011001x11x0x1111101xxxxxxxxxxxxx
14672                                                                      fcvtzu.  */
14673                                                                   return 1424;
14674                                                                 }
14675                                                             }
14676                                                         }
14677                                                     }
14678                                                 }
14679                                             }
14680                                           else
14681                                             {
14682                                               if (((word >> 22) & 0x1) == 0)
14683                                                 {
14684                                                   if (((word >> 23) & 0x1) == 0)
14685                                                     {
14686                                                       /* 33222222222211111111110000000000
14687                                                          10987654321098765432109876543210
14688                                                          111001x1000xxxxx101xxxxxxxxxxxxx
14689                                                          st1w.  */
14690                                                       return 1902;
14691                                                     }
14692                                                   else
14693                                                     {
14694                                                       /* 33222222222211111111110000000000
14695                                                          10987654321098765432109876543210
14696                                                          111001x1100xxxxx101xxxxxxxxxxxxx
14697                                                          st1d.  */
14698                                                       return 1881;
14699                                                     }
14700                                                 }
14701                                               else
14702                                                 {
14703                                                   if (((word >> 23) & 0x1) == 0)
14704                                                     {
14705                                                       /* 33222222222211111111110000000000
14706                                                          10987654321098765432109876543210
14707                                                          111001x1010xxxxx101xxxxxxxxxxxxx
14708                                                          st1w.  */
14709                                                       return 1909;
14710                                                     }
14711                                                   else
14712                                                     {
14713                                                       /* 33222222222211111111110000000000
14714                                                          10987654321098765432109876543210
14715                                                          111001x1110xxxxx101xxxxxxxxxxxxx
14716                                                          st1d.  */
14717                                                       return 1885;
14718                                                     }
14719                                                 }
14720                                             }
14721                                         }
14722                                       else
14723                                         {
14724                                           if (((word >> 31) & 0x1) == 0)
14725                                             {
14726                                               /* 33222222222211111111110000000000
14727                                                  10987654321098765432109876543210
14728                                                  011001x1xx0xxxxx111xxxxxxxxxxxxx
14729                                                  facgt.  */
14730                                               return 1383;
14731                                             }
14732                                           else
14733                                             {
14734                                               if (((word >> 20) & 0x1) == 0)
14735                                                 {
14736                                                   /* 33222222222211111111110000000000
14737                                                      10987654321098765432109876543210
14738                                                      111001x1xx00xxxx111xxxxxxxxxxxxx
14739                                                      st1w.  */
14740                                                   return 1910;
14741                                                 }
14742                                               else
14743                                                 {
14744                                                   if (((word >> 22) & 0x1) == 0)
14745                                                     {
14746                                                       if (((word >> 23) & 0x1) == 0)
14747                                                         {
14748                                                           /* 33222222222211111111110000000000
14749                                                              10987654321098765432109876543210
14750                                                              111001x10001xxxx111xxxxxxxxxxxxx
14751                                                              stnt1w.  */
14752                                                           return 1944;
14753                                                         }
14754                                                       else
14755                                                         {
14756                                                           /* 33222222222211111111110000000000
14757                                                              10987654321098765432109876543210
14758                                                              111001x11001xxxx111xxxxxxxxxxxxx
14759                                                              stnt1d.  */
14760                                                           return 1940;
14761                                                         }
14762                                                     }
14763                                                   else
14764                                                     {
14765                                                       if (((word >> 23) & 0x1) == 0)
14766                                                         {
14767                                                           /* 33222222222211111111110000000000
14768                                                              10987654321098765432109876543210
14769                                                              111001x10101xxxx111xxxxxxxxxxxxx
14770                                                              st3w.  */
14771                                                           return 1928;
14772                                                         }
14773                                                       else
14774                                                         {
14775                                                           /* 33222222222211111111110000000000
14776                                                              10987654321098765432109876543210
14777                                                              111001x11101xxxx111xxxxxxxxxxxxx
14778                                                              st3d.  */
14779                                                           return 1924;
14780                                                         }
14781                                                     }
14782                                                 }
14783                                             }
14784                                         }
14785                                     }
14786                                 }
14787                             }
14788                           else
14789                             {
14790                               if (((word >> 30) & 0x1) == 0)
14791                                 {
14792                                   if (((word >> 14) & 0x1) == 0)
14793                                     {
14794                                       if (((word >> 20) & 0x1) == 0)
14795                                         {
14796                                           if (((word >> 31) & 0x1) == 0)
14797                                             {
14798                                               if (((word >> 16) & 0x1) == 0)
14799                                                 {
14800                                                   if (((word >> 17) & 0x1) == 0)
14801                                                     {
14802                                                       if (((word >> 18) & 0x1) == 0)
14803                                                         {
14804                                                           if (((word >> 19) & 0x1) == 0)
14805                                                             {
14806                                                               /* 33222222222211111111110000000000
14807                                                                  10987654321098765432109876543210
14808                                                                  001001x1xx10000010xxxxxxxxxxxxxx
14809                                                                  cntp.  */
14810                                                               return 1352;
14811                                                             }
14812                                                           else
14813                                                             {
14814                                                               if (((word >> 10) & 0x1) == 0)
14815                                                                 {
14816                                                                   if (((word >> 11) & 0x1) == 0)
14817                                                                     {
14818                                                                       if (((word >> 12) & 0x1) == 0)
14819                                                                         {
14820                                                                           /* 33222222222211111111110000000000
14821                                                                              10987654321098765432109876543210
14822                                                                              001001x1xx10100010x000xxxxxxxxxx
14823                                                                              sqincp.  */
14824                                                                           return 1859;
14825                                                                         }
14826                                                                       else
14827                                                                         {
14828                                                                           /* 33222222222211111111110000000000
14829                                                                              10987654321098765432109876543210
14830                                                                              001001x1xx10100010x100xxxxxxxxxx
14831                                                                              wrffr.  */
14832                                                                           return 2032;
14833                                                                         }
14834                                                                     }
14835                                                                   else
14836                                                                     {
14837                                                                       /* 33222222222211111111110000000000
14838                                                                          10987654321098765432109876543210
14839                                                                          001001x1xx10100010xx10xxxxxxxxxx
14840                                                                          sqincp.  */
14841                                                                       return 1861;
14842                                                                     }
14843                                                                 }
14844                                                               else
14845                                                                 {
14846                                                                   /* 33222222222211111111110000000000
14847                                                                      10987654321098765432109876543210
14848                                                                      001001x1xx10100010xxx1xxxxxxxxxx
14849                                                                      sqincp.  */
14850                                                                   return 1860;
14851                                                                 }
14852                                                             }
14853                                                         }
14854                                                       else
14855                                                         {
14856                                                           if (((word >> 11) & 0x1) == 0)
14857                                                             {
14858                                                               if (((word >> 12) & 0x1) == 0)
14859                                                                 {
14860                                                                   /* 33222222222211111111110000000000
14861                                                                      10987654321098765432109876543210
14862                                                                      001001x1xx10x10010x00xxxxxxxxxxx
14863                                                                      incp.  */
14864                                                                   return 1490;
14865                                                                 }
14866                                                               else
14867                                                                 {
14868                                                                   /* 33222222222211111111110000000000
14869                                                                      10987654321098765432109876543210
14870                                                                      001001x1xx10x10010x10xxxxxxxxxxx
14871                                                                      setffr.  */
14872                                                                   return 1826;
14873                                                                 }
14874                                                             }
14875                                                           else
14876                                                             {
14877                                                               /* 33222222222211111111110000000000
14878                                                                  10987654321098765432109876543210
14879                                                                  001001x1xx10x10010xx1xxxxxxxxxxx
14880                                                                  incp.  */
14881                                                               return 1491;
14882                                                             }
14883                                                         }
14884                                                     }
14885                                                   else
14886                                                     {
14887                                                       if (((word >> 10) & 0x1) == 0)
14888                                                         {
14889                                                           if (((word >> 11) & 0x1) == 0)
14890                                                             {
14891                                                               /* 33222222222211111111110000000000
14892                                                                  10987654321098765432109876543210
14893                                                                  001001x1xx10xx1010xx00xxxxxxxxxx
14894                                                                  sqdecp.  */
14895                                                               return 1845;
14896                                                             }
14897                                                           else
14898                                                             {
14899                                                               /* 33222222222211111111110000000000
14900                                                                  10987654321098765432109876543210
14901                                                                  001001x1xx10xx1010xx10xxxxxxxxxx
14902                                                                  sqdecp.  */
14903                                                               return 1847;
14904                                                             }
14905                                                         }
14906                                                       else
14907                                                         {
14908                                                           /* 33222222222211111111110000000000
14909                                                              10987654321098765432109876543210
14910                                                              001001x1xx10xx1010xxx1xxxxxxxxxx
14911                                                              sqdecp.  */
14912                                                           return 1846;
14913                                                         }
14914                                                     }
14915                                                 }
14916                                               else
14917                                                 {
14918                                                   if (((word >> 10) & 0x1) == 0)
14919                                                     {
14920                                                       if (((word >> 11) & 0x1) == 0)
14921                                                         {
14922                                                           if (((word >> 17) & 0x1) == 0)
14923                                                             {
14924                                                               if (((word >> 18) & 0x1) == 0)
14925                                                                 {
14926                                                                   /* 33222222222211111111110000000000
14927                                                                      10987654321098765432109876543210
14928                                                                      001001x1xx10x00110xx00xxxxxxxxxx
14929                                                                      uqincp.  */
14930                                                                   return 2007;
14931                                                                 }
14932                                                               else
14933                                                                 {
14934                                                                   /* 33222222222211111111110000000000
14935                                                                      10987654321098765432109876543210
14936                                                                      001001x1xx10x10110xx00xxxxxxxxxx
14937                                                                      decp.  */
14938                                                                   return 1365;
14939                                                                 }
14940                                                             }
14941                                                           else
14942                                                             {
14943                                                               /* 33222222222211111111110000000000
14944                                                                  10987654321098765432109876543210
14945                                                                  001001x1xx10xx1110xx00xxxxxxxxxx
14946                                                                  uqdecp.  */
14947                                                               return 1993;
14948                                                             }
14949                                                         }
14950                                                       else
14951                                                         {
14952                                                           if (((word >> 17) & 0x1) == 0)
14953                                                             {
14954                                                               if (((word >> 18) & 0x1) == 0)
14955                                                                 {
14956                                                                   /* 33222222222211111111110000000000
14957                                                                      10987654321098765432109876543210
14958                                                                      001001x1xx10x00110xx10xxxxxxxxxx
14959                                                                      uqincp.  */
14960                                                                   return 2008;
14961                                                                 }
14962                                                               else
14963                                                                 {
14964                                                                   /* 33222222222211111111110000000000
14965                                                                      10987654321098765432109876543210
14966                                                                      001001x1xx10x10110xx10xxxxxxxxxx
14967                                                                      decp.  */
14968                                                                   return 1366;
14969                                                                 }
14970                                                             }
14971                                                           else
14972                                                             {
14973                                                               /* 33222222222211111111110000000000
14974                                                                  10987654321098765432109876543210
14975                                                                  001001x1xx10xx1110xx10xxxxxxxxxx
14976                                                                  uqdecp.  */
14977                                                               return 1994;
14978                                                             }
14979                                                         }
14980                                                     }
14981                                                   else
14982                                                     {
14983                                                       if (((word >> 17) & 0x1) == 0)
14984                                                         {
14985                                                           /* 33222222222211111111110000000000
14986                                                              10987654321098765432109876543210
14987                                                              001001x1xx10xx0110xxx1xxxxxxxxxx
14988                                                              uqincp.  */
14989                                                           return 2009;
14990                                                         }
14991                                                       else
14992                                                         {
14993                                                           /* 33222222222211111111110000000000
14994                                                              10987654321098765432109876543210
14995                                                              001001x1xx10xx1110xxx1xxxxxxxxxx
14996                                                              uqdecp.  */
14997                                                           return 1995;
14998                                                         }
14999                                                     }
15000                                                 }
15001                                             }
15002                                           else
15003                                             {
15004                                               if (((word >> 22) & 0x1) == 0)
15005                                                 {
15006                                                   if (((word >> 23) & 0x1) == 0)
15007                                                     {
15008                                                       /* 33222222222211111111110000000000
15009                                                          10987654321098765432109876543210
15010                                                          101001x10010xxxx10xxxxxxxxxxxxxx
15011                                                          ld1sh.  */
15012                                                       return 1583;
15013                                                     }
15014                                                   else
15015                                                     {
15016                                                       /* 33222222222211111111110000000000
15017                                                          10987654321098765432109876543210
15018                                                          101001x11010xxxx10xxxxxxxxxxxxxx
15019                                                          ld1sb.  */
15020                                                       return 1570;
15021                                                     }
15022                                                 }
15023                                               else
15024                                                 {
15025                                                   if (((word >> 23) & 0x1) == 0)
15026                                                     {
15027                                                       /* 33222222222211111111110000000000
15028                                                          10987654321098765432109876543210
15029                                                          101001x10110xxxx10xxxxxxxxxxxxxx
15030                                                          ld1w.  */
15031                                                       return 1602;
15032                                                     }
15033                                                   else
15034                                                     {
15035                                                       /* 33222222222211111111110000000000
15036                                                          10987654321098765432109876543210
15037                                                          101001x11110xxxx10xxxxxxxxxxxxxx
15038                                                          ld1d.  */
15039                                                       return 1522;
15040                                                     }
15041                                                 }
15042                                             }
15043                                         }
15044                                       else
15045                                         {
15046                                           if (((word >> 22) & 0x1) == 0)
15047                                             {
15048                                               if (((word >> 23) & 0x1) == 0)
15049                                                 {
15050                                                   /* 33222222222211111111110000000000
15051                                                      10987654321098765432109876543210
15052                                                      x01001x10011xxxx10xxxxxxxxxxxxxx
15053                                                      ldnf1sh.  */
15054                                                   return 1716;
15055                                                 }
15056                                               else
15057                                                 {
15058                                                   /* 33222222222211111111110000000000
15059                                                      10987654321098765432109876543210
15060                                                      x01001x11011xxxx10xxxxxxxxxxxxxx
15061                                                      ldnf1sb.  */
15062                                                   return 1713;
15063                                                 }
15064                                             }
15065                                           else
15066                                             {
15067                                               if (((word >> 23) & 0x1) == 0)
15068                                                 {
15069                                                   /* 33222222222211111111110000000000
15070                                                      10987654321098765432109876543210
15071                                                      x01001x10111xxxx10xxxxxxxxxxxxxx
15072                                                      ldnf1w.  */
15073                                                   return 1719;
15074                                                 }
15075                                               else
15076                                                 {
15077                                                   /* 33222222222211111111110000000000
15078                                                      10987654321098765432109876543210
15079                                                      x01001x11111xxxx10xxxxxxxxxxxxxx
15080                                                      ldnf1d.  */
15081                                                   return 1708;
15082                                                 }
15083                                             }
15084                                         }
15085                                     }
15086                                   else
15087                                     {
15088                                       if (((word >> 31) & 0x1) == 0)
15089                                         {
15090                                           if (((word >> 16) & 0x1) == 0)
15091                                             {
15092                                               if (((word >> 17) & 0x1) == 0)
15093                                                 {
15094                                                   if (((word >> 18) & 0x1) == 0)
15095                                                     {
15096                                                       if (((word >> 19) & 0x1) == 0)
15097                                                         {
15098                                                           if (((word >> 20) & 0x1) == 0)
15099                                                             {
15100                                                               /* 33222222222211111111110000000000
15101                                                                  10987654321098765432109876543210
15102                                                                  001001x1xx10000011xxxxxxxxxxxxxx
15103                                                                  add.  */
15104                                                               return 1279;
15105                                                             }
15106                                                           else
15107                                                             {
15108                                                               /* 33222222222211111111110000000000
15109                                                                  10987654321098765432109876543210
15110                                                                  001001x1xx11000011xxxxxxxxxxxxxx
15111                                                                  mul.  */
15112                                                               return 1748;
15113                                                             }
15114                                                         }
15115                                                       else
15116                                                         {
15117                                                           if (((word >> 20) & 0x1) == 0)
15118                                                             {
15119                                                               /* 33222222222211111111110000000000
15120                                                                  10987654321098765432109876543210
15121                                                                  001001x1xx10100011xxxxxxxxxxxxxx
15122                                                                  smax.  */
15123                                                               return 1827;
15124                                                             }
15125                                                           else
15126                                                             {
15127                                                               /* 33222222222211111111110000000000
15128                                                                  10987654321098765432109876543210
15129                                                                  001001x1xx11100011xxxxxxxxxxxxxx
15130                                                                  dup.  */
15131                                                               return 1371;
15132                                                             }
15133                                                         }
15134                                                     }
15135                                                   else
15136                                                     {
15137                                                       /* 33222222222211111111110000000000
15138                                                          10987654321098765432109876543210
15139                                                          001001x1xx1xx10011xxxxxxxxxxxxxx
15140                                                          sqadd.  */
15141                                                       return 1836;
15142                                                     }
15143                                                 }
15144                                               else
15145                                                 {
15146                                                   if (((word >> 18) & 0x1) == 0)
15147                                                     {
15148                                                       /* 33222222222211111111110000000000
15149                                                          10987654321098765432109876543210
15150                                                          001001x1xx1xx01011xxxxxxxxxxxxxx
15151                                                          smin.  */
15152                                                       return 1830;
15153                                                     }
15154                                                   else
15155                                                     {
15156                                                       /* 33222222222211111111110000000000
15157                                                          10987654321098765432109876543210
15158                                                          001001x1xx1xx11011xxxxxxxxxxxxxx
15159                                                          sqsub.  */
15160                                                       return 1866;
15161                                                     }
15162                                                 }
15163                                             }
15164                                           else
15165                                             {
15166                                               if (((word >> 17) & 0x1) == 0)
15167                                                 {
15168                                                   if (((word >> 18) & 0x1) == 0)
15169                                                     {
15170                                                       if (((word >> 19) & 0x1) == 0)
15171                                                         {
15172                                                           /* 33222222222211111111110000000000
15173                                                              10987654321098765432109876543210
15174                                                              001001x1xx1x000111xxxxxxxxxxxxxx
15175                                                              sub.  */
15176                                                           return 1948;
15177                                                         }
15178                                                       else
15179                                                         {
15180                                                           if (((word >> 20) & 0x1) == 0)
15181                                                             {
15182                                                               /* 33222222222211111111110000000000
15183                                                                  10987654321098765432109876543210
15184                                                                  001001x1xx10100111xxxxxxxxxxxxxx
15185                                                                  umax.  */
15186                                                               return 1976;
15187                                                             }
15188                                                           else
15189                                                             {
15190                                                               /* 33222222222211111111110000000000
15191                                                                  10987654321098765432109876543210
15192                                                                  001001x1xx11100111xxxxxxxxxxxxxx
15193                                                                  fdup.  */
15194                                                               return 1427;
15195                                                             }
15196                                                         }
15197                                                     }
15198                                                   else
15199                                                     {
15200                                                       /* 33222222222211111111110000000000
15201                                                          10987654321098765432109876543210
15202                                                          001001x1xx1xx10111xxxxxxxxxxxxxx
15203                                                          uqadd.  */
15204                                                       return 1984;
15205                                                     }
15206                                                 }
15207                                               else
15208                                                 {
15209                                                   if (((word >> 18) & 0x1) == 0)
15210                                                     {
15211                                                       if (((word >> 19) & 0x1) == 0)
15212                                                         {
15213                                                           /* 33222222222211111111110000000000
15214                                                              10987654321098765432109876543210
15215                                                              001001x1xx1x001111xxxxxxxxxxxxxx
15216                                                              subr.  */
15217                                                           return 1950;
15218                                                         }
15219                                                       else
15220                                                         {
15221                                                           /* 33222222222211111111110000000000
15222                                                              10987654321098765432109876543210
15223                                                              001001x1xx1x101111xxxxxxxxxxxxxx
15224                                                              umin.  */
15225                                                           return 1979;
15226                                                         }
15227                                                     }
15228                                                   else
15229                                                     {
15230                                                       /* 33222222222211111111110000000000
15231                                                          10987654321098765432109876543210
15232                                                          001001x1xx1xx11111xxxxxxxxxxxxxx
15233                                                          uqsub.  */
15234                                                       return 2014;
15235                                                     }
15236                                                 }
15237                                             }
15238                                         }
15239                                       else
15240                                         {
15241                                           if (((word >> 13) & 0x1) == 0)
15242                                             {
15243                                               if (((word >> 22) & 0x1) == 0)
15244                                                 {
15245                                                   if (((word >> 23) & 0x1) == 0)
15246                                                     {
15247                                                       /* 33222222222211111111110000000000
15248                                                          10987654321098765432109876543210
15249                                                          101001x1001xxxxx110xxxxxxxxxxxxx
15250                                                          ld2w.  */
15251                                                       return 1610;
15252                                                     }
15253                                                   else
15254                                                     {
15255                                                       /* 33222222222211111111110000000000
15256                                                          10987654321098765432109876543210
15257                                                          101001x1101xxxxx110xxxxxxxxxxxxx
15258                                                          ld2d.  */
15259                                                       return 1606;
15260                                                     }
15261                                                 }
15262                                               else
15263                                                 {
15264                                                   if (((word >> 23) & 0x1) == 0)
15265                                                     {
15266                                                       /* 33222222222211111111110000000000
15267                                                          10987654321098765432109876543210
15268                                                          101001x1011xxxxx110xxxxxxxxxxxxx
15269                                                          ld4w.  */
15270                                                       return 1626;
15271                                                     }
15272                                                   else
15273                                                     {
15274                                                       /* 33222222222211111111110000000000
15275                                                          10987654321098765432109876543210
15276                                                          101001x1111xxxxx110xxxxxxxxxxxxx
15277                                                          ld4d.  */
15278                                                       return 1622;
15279                                                     }
15280                                                 }
15281                                             }
15282                                           else
15283                                             {
15284                                               if (((word >> 22) & 0x1) == 0)
15285                                                 {
15286                                                   if (((word >> 23) & 0x1) == 0)
15287                                                     {
15288                                                       /* 33222222222211111111110000000000
15289                                                          10987654321098765432109876543210
15290                                                          101001x1001xxxxx111xxxxxxxxxxxxx
15291                                                          ld2w.  */
15292                                                       return 1611;
15293                                                     }
15294                                                   else
15295                                                     {
15296                                                       /* 33222222222211111111110000000000
15297                                                          10987654321098765432109876543210
15298                                                          101001x1101xxxxx111xxxxxxxxxxxxx
15299                                                          ld2d.  */
15300                                                       return 1607;
15301                                                     }
15302                                                 }
15303                                               else
15304                                                 {
15305                                                   if (((word >> 23) & 0x1) == 0)
15306                                                     {
15307                                                       /* 33222222222211111111110000000000
15308                                                          10987654321098765432109876543210
15309                                                          101001x1011xxxxx111xxxxxxxxxxxxx
15310                                                          ld4w.  */
15311                                                       return 1627;
15312                                                     }
15313                                                   else
15314                                                     {
15315                                                       /* 33222222222211111111110000000000
15316                                                          10987654321098765432109876543210
15317                                                          101001x1111xxxxx111xxxxxxxxxxxxx
15318                                                          ld4d.  */
15319                                                       return 1623;
15320                                                     }
15321                                                 }
15322                                             }
15323                                         }
15324                                     }
15325                                 }
15326                               else
15327                                 {
15328                                   if (((word >> 13) & 0x1) == 0)
15329                                     {
15330                                       if (((word >> 31) & 0x1) == 0)
15331                                         {
15332                                           if (((word >> 14) & 0x1) == 0)
15333                                             {
15334                                               /* 33222222222211111111110000000000
15335                                                  10987654321098765432109876543210
15336                                                  011001x1xx1xxxxx100xxxxxxxxxxxxx
15337                                                  fmad.  */
15338                                               return 1429;
15339                                             }
15340                                           else
15341                                             {
15342                                               /* 33222222222211111111110000000000
15343                                                  10987654321098765432109876543210
15344                                                  011001x1xx1xxxxx110xxxxxxxxxxxxx
15345                                                  fnmad.  */
15346                                               return 1459;
15347                                             }
15348                                         }
15349                                       else
15350                                         {
15351                                           if (((word >> 22) & 0x1) == 0)
15352                                             {
15353                                               if (((word >> 23) & 0x1) == 0)
15354                                                 {
15355                                                   /* 33222222222211111111110000000000
15356                                                      10987654321098765432109876543210
15357                                                      111001x1001xxxxx1x0xxxxxxxxxxxxx
15358                                                      st1w.  */
15359                                                   return 1903;
15360                                                 }
15361                                               else
15362                                                 {
15363                                                   /* 33222222222211111111110000000000
15364                                                      10987654321098765432109876543210
15365                                                      111001x1101xxxxx1x0xxxxxxxxxxxxx
15366                                                      st1d.  */
15367                                                   return 1882;
15368                                                 }
15369                                             }
15370                                           else
15371                                             {
15372                                               /* 33222222222211111111110000000000
15373                                                  10987654321098765432109876543210
15374                                                  111001x1x11xxxxx1x0xxxxxxxxxxxxx
15375                                                  st1w.  */
15376                                               return 1908;
15377                                             }
15378                                         }
15379                                     }
15380                                   else
15381                                     {
15382                                       if (((word >> 14) & 0x1) == 0)
15383                                         {
15384                                           if (((word >> 31) & 0x1) == 0)
15385                                             {
15386                                               /* 33222222222211111111110000000000
15387                                                  10987654321098765432109876543210
15388                                                  011001x1xx1xxxxx101xxxxxxxxxxxxx
15389                                                  fmsb.  */
15390                                               return 1450;
15391                                             }
15392                                           else
15393                                             {
15394                                               if (((word >> 22) & 0x1) == 0)
15395                                                 {
15396                                                   if (((word >> 23) & 0x1) == 0)
15397                                                     {
15398                                                       /* 33222222222211111111110000000000
15399                                                          10987654321098765432109876543210
15400                                                          111001x1001xxxxx101xxxxxxxxxxxxx
15401                                                          st1w.  */
15402                                                       return 1904;
15403                                                     }
15404                                                   else
15405                                                     {
15406                                                       /* 33222222222211111111110000000000
15407                                                          10987654321098765432109876543210
15408                                                          111001x1101xxxxx101xxxxxxxxxxxxx
15409                                                          st1d.  */
15410                                                       return 1883;
15411                                                     }
15412                                                 }
15413                                               else
15414                                                 {
15415                                                   /* 33222222222211111111110000000000
15416                                                      10987654321098765432109876543210
15417                                                      111001x1x11xxxxx101xxxxxxxxxxxxx
15418                                                      st1w.  */
15419                                                   return 1911;
15420                                                 }
15421                                             }
15422                                         }
15423                                       else
15424                                         {
15425                                           if (((word >> 31) & 0x1) == 0)
15426                                             {
15427                                               /* 33222222222211111111110000000000
15428                                                  10987654321098765432109876543210
15429                                                  011001x1xx1xxxxx111xxxxxxxxxxxxx
15430                                                  fnmsb.  */
15431                                               return 1462;
15432                                             }
15433                                           else
15434                                             {
15435                                               if (((word >> 20) & 0x1) == 0)
15436                                                 {
15437                                                   if (((word >> 23) & 0x1) == 0)
15438                                                     {
15439                                                       /* 33222222222211111111110000000000
15440                                                          10987654321098765432109876543210
15441                                                          111001x10x10xxxx111xxxxxxxxxxxxx
15442                                                          st1w.  */
15443                                                       return 1912;
15444                                                     }
15445                                                   else
15446                                                     {
15447                                                       /* 33222222222211111111110000000000
15448                                                          10987654321098765432109876543210
15449                                                          111001x11x10xxxx111xxxxxxxxxxxxx
15450                                                          st1d.  */
15451                                                       return 1886;
15452                                                     }
15453                                                 }
15454                                               else
15455                                                 {
15456                                                   if (((word >> 22) & 0x1) == 0)
15457                                                     {
15458                                                       if (((word >> 23) & 0x1) == 0)
15459                                                         {
15460                                                           /* 33222222222211111111110000000000
15461                                                              10987654321098765432109876543210
15462                                                              111001x10011xxxx111xxxxxxxxxxxxx
15463                                                              st2w.  */
15464                                                           return 1920;
15465                                                         }
15466                                                       else
15467                                                         {
15468                                                           /* 33222222222211111111110000000000
15469                                                              10987654321098765432109876543210
15470                                                              111001x11011xxxx111xxxxxxxxxxxxx
15471                                                              st2d.  */
15472                                                           return 1916;
15473                                                         }
15474                                                     }
15475                                                   else
15476                                                     {
15477                                                       if (((word >> 23) & 0x1) == 0)
15478                                                         {
15479                                                           /* 33222222222211111111110000000000
15480                                                              10987654321098765432109876543210
15481                                                              111001x10111xxxx111xxxxxxxxxxxxx
15482                                                              st4w.  */
15483                                                           return 1936;
15484                                                         }
15485                                                       else
15486                                                         {
15487                                                           /* 33222222222211111111110000000000
15488                                                              10987654321098765432109876543210
15489                                                              111001x11111xxxx111xxxxxxxxxxxxx
15490                                                              st4d.  */
15491                                                           return 1932;
15492                                                         }
15493                                                     }
15494                                                 }
15495                                             }
15496                                         }
15497                                     }
15498                                 }
15499                             }
15500                         }
15501                     }
15502                 }
15503             }
15504           else
15505             {
15506               if (((word >> 29) & 0x1) == 0)
15507                 {
15508                   if (((word >> 30) & 0x1) == 0)
15509                     {
15510                       if (((word >> 31) & 0x1) == 0)
15511                         {
15512                           /* 33222222222211111111110000000000
15513                              10987654321098765432109876543210
15514                              000101xxxxxxxxxxxxxxxxxxxxxxxxxx
15515                              b.  */
15516                           return 636;
15517                         }
15518                       else
15519                         {
15520                           /* 33222222222211111111110000000000
15521                              10987654321098765432109876543210
15522                              100101xxxxxxxxxxxxxxxxxxxxxxxxxx
15523                              bl.  */
15524                           return 637;
15525                         }
15526                     }
15527                   else
15528                     {
15529                       if (((word >> 24) & 0x1) == 0)
15530                         {
15531                           if (((word >> 4) & 0x1) == 0)
15532                             {
15533                               if (((word >> 25) & 0x1) == 0)
15534                                 {
15535                                   if (((word >> 31) & 0x1) == 0)
15536                                     {
15537                                       /* 33222222222211111111110000000000
15538                                          10987654321098765432109876543210
15539                                          01010100xxxxxxxxxxxxxxxxxxx0xxxx
15540                                          b.c.  */
15541                                       return 657;
15542                                     }
15543                                   else
15544                                     {
15545                                       if (((word >> 0) & 0x1) == 0)
15546                                         {
15547                                           if (((word >> 1) & 0x1) == 0)
15548                                             {
15549                                               if (((word >> 21) & 0x1) == 0)
15550                                                 {
15551                                                   /* 33222222222211111111110000000000
15552                                                      10987654321098765432109876543210
15553                                                      11010100xx0xxxxxxxxxxxxxxxx0xx00
15554                                                      hlt.  */
15555                                                   return 753;
15556                                                 }
15557                                               else
15558                                                 {
15559                                                   if (((word >> 22) & 0x1) == 0)
15560                                                     {
15561                                                       /* 33222222222211111111110000000000
15562                                                          10987654321098765432109876543210
15563                                                          11010100x01xxxxxxxxxxxxxxxx0xx00
15564                                                          brk.  */
15565                                                       return 752;
15566                                                     }
15567                                                   else
15568                                                     {
15569                                                       /* 33222222222211111111110000000000
15570                                                          10987654321098765432109876543210
15571                                                          11010100x11xxxxxxxxxxxxxxxx0xx00
15572                                                          tcancel.  */
15573                                                       return 1192;
15574                                                     }
15575                                                 }
15576                                             }
15577                                           else
15578                                             {
15579                                               if (((word >> 21) & 0x1) == 0)
15580                                                 {
15581                                                   /* 33222222222211111111110000000000
15582                                                      10987654321098765432109876543210
15583                                                      11010100xx0xxxxxxxxxxxxxxxx0xx10
15584                                                      hvc.  */
15585                                                   return 750;
15586                                                 }
15587                                               else
15588                                                 {
15589                                                   /* 33222222222211111111110000000000
15590                                                      10987654321098765432109876543210
15591                                                      11010100xx1xxxxxxxxxxxxxxxx0xx10
15592                                                      dcps2.  */
15593                                                   return 756;
15594                                                 }
15595                                             }
15596                                         }
15597                                       else
15598                                         {
15599                                           if (((word >> 1) & 0x1) == 0)
15600                                             {
15601                                               if (((word >> 21) & 0x1) == 0)
15602                                                 {
15603                                                   /* 33222222222211111111110000000000
15604                                                      10987654321098765432109876543210
15605                                                      11010100xx0xxxxxxxxxxxxxxxx0xx01
15606                                                      svc.  */
15607                                                   return 749;
15608                                                 }
15609                                               else
15610                                                 {
15611                                                   /* 33222222222211111111110000000000
15612                                                      10987654321098765432109876543210
15613                                                      11010100xx1xxxxxxxxxxxxxxxx0xx01
15614                                                      dcps1.  */
15615                                                   return 755;
15616                                                 }
15617                                             }
15618                                           else
15619                                             {
15620                                               if (((word >> 21) & 0x1) == 0)
15621                                                 {
15622                                                   /* 33222222222211111111110000000000
15623                                                      10987654321098765432109876543210
15624                                                      11010100xx0xxxxxxxxxxxxxxxx0xx11
15625                                                      smc.  */
15626                                                   return 751;
15627                                                 }
15628                                               else
15629                                                 {
15630                                                   /* 33222222222211111111110000000000
15631                                                      10987654321098765432109876543210
15632                                                      11010100xx1xxxxxxxxxxxxxxxx0xx11
15633                                                      dcps3.  */
15634                                                   return 757;
15635                                                 }
15636                                             }
15637                                         }
15638                                     }
15639                                 }
15640                               else
15641                                 {
15642                                   if (((word >> 21) & 0x1) == 0)
15643                                     {
15644                                       if (((word >> 22) & 0x1) == 0)
15645                                         {
15646                                           if (((word >> 23) & 0x1) == 0)
15647                                             {
15648                                               /* 33222222222211111111110000000000
15649                                                  10987654321098765432109876543210
15650                                                  x1010110000xxxxxxxxxxxxxxxx0xxxx
15651                                                  br.  */
15652                                               return 638;
15653                                             }
15654                                           else
15655                                             {
15656                                               /* 33222222222211111111110000000000
15657                                                  10987654321098765432109876543210
15658                                                  x1010110100xxxxxxxxxxxxxxxx0xxxx
15659                                                  eret.  */
15660                                               return 641;
15661                                             }
15662                                         }
15663                                       else
15664                                         {
15665                                           /* 33222222222211111111110000000000
15666                                              10987654321098765432109876543210
15667                                              x1010110x10xxxxxxxxxxxxxxxx0xxxx
15668                                              ret.  */
15669                                           return 640;
15670                                         }
15671                                     }
15672                                   else
15673                                     {
15674                                       if (((word >> 23) & 0x1) == 0)
15675                                         {
15676                                           /* 33222222222211111111110000000000
15677                                              10987654321098765432109876543210
15678                                              x10101100x1xxxxxxxxxxxxxxxx0xxxx
15679                                              blr.  */
15680                                           return 639;
15681                                         }
15682                                       else
15683                                         {
15684                                           /* 33222222222211111111110000000000
15685                                              10987654321098765432109876543210
15686                                              x10101101x1xxxxxxxxxxxxxxxx0xxxx
15687                                              drps.  */
15688                                           return 642;
15689                                         }
15690                                     }
15691                                 }
15692                             }
15693                           else
15694                             {
15695                               if (((word >> 10) & 0x1) == 0)
15696                                 {
15697                                   if (((word >> 21) & 0x1) == 0)
15698                                     {
15699                                       if (((word >> 22) & 0x1) == 0)
15700                                         {
15701                                           if (((word >> 23) & 0x1) == 0)
15702                                             {
15703                                               /* 33222222222211111111110000000000
15704                                                  10987654321098765432109876543210
15705                                                  x10101x0000xxxxxxxxxx0xxxxx1xxxx
15706                                                  braaz.  */
15707                                               return 647;
15708                                             }
15709                                           else
15710                                             {
15711                                               /* 33222222222211111111110000000000
15712                                                  10987654321098765432109876543210
15713                                                  x10101x0100xxxxxxxxxx0xxxxx1xxxx
15714                                                  eretaa.  */
15715                                               return 653;
15716                                             }
15717                                         }
15718                                       else
15719                                         {
15720                                           /* 33222222222211111111110000000000
15721                                              10987654321098765432109876543210
15722                                              x10101x0x10xxxxxxxxxx0xxxxx1xxxx
15723                                              retaa.  */
15724                                           return 651;
15725                                         }
15726                                     }
15727                                   else
15728                                     {
15729                                       /* 33222222222211111111110000000000
15730                                          10987654321098765432109876543210
15731                                          x10101x0xx1xxxxxxxxxx0xxxxx1xxxx
15732                                          blraaz.  */
15733                                       return 649;
15734                                     }
15735                                 }
15736                               else
15737                                 {
15738                                   if (((word >> 21) & 0x1) == 0)
15739                                     {
15740                                       if (((word >> 22) & 0x1) == 0)
15741                                         {
15742                                           if (((word >> 23) & 0x1) == 0)
15743                                             {
15744                                               /* 33222222222211111111110000000000
15745                                                  10987654321098765432109876543210
15746                                                  x10101x0000xxxxxxxxxx1xxxxx1xxxx
15747                                                  brabz.  */
15748                                               return 648;
15749                                             }
15750                                           else
15751                                             {
15752                                               /* 33222222222211111111110000000000
15753                                                  10987654321098765432109876543210
15754                                                  x10101x0100xxxxxxxxxx1xxxxx1xxxx
15755                                                  eretab.  */
15756                                               return 654;
15757                                             }
15758                                         }
15759                                       else
15760                                         {
15761                                           /* 33222222222211111111110000000000
15762                                              10987654321098765432109876543210
15763                                              x10101x0x10xxxxxxxxxx1xxxxx1xxxx
15764                                              retab.  */
15765                                           return 652;
15766                                         }
15767                                     }
15768                                   else
15769                                     {
15770                                       /* 33222222222211111111110000000000
15771                                          10987654321098765432109876543210
15772                                          x10101x0xx1xxxxxxxxxx1xxxxx1xxxx
15773                                          blrabz.  */
15774                                       return 650;
15775                                     }
15776                                 }
15777                             }
15778                         }
15779                       else
15780                         {
15781                           if (((word >> 21) & 0x1) == 0)
15782                             {
15783                               if (((word >> 25) & 0x1) == 0)
15784                                 {
15785                                   /* 33222222222211111111110000000000
15786                                      10987654321098765432109876543210
15787                                      x1010101xx0xxxxxxxxxxxxxxxxxxxxx
15788                                      xaflag.  */
15789                                   return 811;
15790                                 }
15791                               else
15792                                 {
15793                                   if (((word >> 10) & 0x1) == 0)
15794                                     {
15795                                       /* 33222222222211111111110000000000
15796                                          10987654321098765432109876543210
15797                                          x1010111xx0xxxxxxxxxx0xxxxxxxxxx
15798                                          braa.  */
15799                                       return 643;
15800                                     }
15801                                   else
15802                                     {
15803                                       /* 33222222222211111111110000000000
15804                                          10987654321098765432109876543210
15805                                          x1010111xx0xxxxxxxxxx1xxxxxxxxxx
15806                                          brab.  */
15807                                       return 644;
15808                                     }
15809                                 }
15810                             }
15811                           else
15812                             {
15813                               if (((word >> 25) & 0x1) == 0)
15814                                 {
15815                                   /* 33222222222211111111110000000000
15816                                      10987654321098765432109876543210
15817                                      x1010101xx1xxxxxxxxxxxxxxxxxxxxx
15818                                      tstart.  */
15819                                   return 1189;
15820                                 }
15821                               else
15822                                 {
15823                                   if (((word >> 10) & 0x1) == 0)
15824                                     {
15825                                       /* 33222222222211111111110000000000
15826                                          10987654321098765432109876543210
15827                                          x1010111xx1xxxxxxxxxx0xxxxxxxxxx
15828                                          blraa.  */
15829                                       return 645;
15830                                     }
15831                                   else
15832                                     {
15833                                       /* 33222222222211111111110000000000
15834                                          10987654321098765432109876543210
15835                                          x1010111xx1xxxxxxxxxx1xxxxxxxxxx
15836                                          blrab.  */
15837                                       return 646;
15838                                     }
15839                                 }
15840                             }
15841                         }
15842                     }
15843                 }
15844               else
15845                 {
15846                   if (((word >> 24) & 0x1) == 0)
15847                     {
15848                       if (((word >> 25) & 0x1) == 0)
15849                         {
15850                           /* 33222222222211111111110000000000
15851                              10987654321098765432109876543210
15852                              xx110100xxxxxxxxxxxxxxxxxxxxxxxx
15853                              cbz.  */
15854                           return 655;
15855                         }
15856                       else
15857                         {
15858                           /* 33222222222211111111110000000000
15859                              10987654321098765432109876543210
15860                              xx110110xxxxxxxxxxxxxxxxxxxxxxxx
15861                              tbz.  */
15862                           return 1240;
15863                         }
15864                     }
15865                   else
15866                     {
15867                       if (((word >> 25) & 0x1) == 0)
15868                         {
15869                           /* 33222222222211111111110000000000
15870                              10987654321098765432109876543210
15871                              xx110101xxxxxxxxxxxxxxxxxxxxxxxx
15872                              cbnz.  */
15873                           return 656;
15874                         }
15875                       else
15876                         {
15877                           /* 33222222222211111111110000000000
15878                              10987654321098765432109876543210
15879                              xx110111xxxxxxxxxxxxxxxxxxxxxxxx
15880                              tbnz.  */
15881                           return 1241;
15882                         }
15883                     }
15884                 }
15885             }
15886         }
15887       else
15888         {
15889           if (((word >> 25) & 0x1) == 0)
15890             {
15891               if (((word >> 28) & 0x1) == 0)
15892                 {
15893                   if (((word >> 22) & 0x1) == 0)
15894                     {
15895                       if (((word >> 23) & 0x1) == 0)
15896                         {
15897                           if (((word >> 24) & 0x1) == 0)
15898                             {
15899                               if (((word >> 29) & 0x1) == 0)
15900                                 {
15901                                   /* 33222222222211111111110000000000
15902                                      10987654321098765432109876543210
15903                                      xx00110000xxxxxxxxxxxxxxxxxxxxxx
15904                                      st4.  */
15905                                   return 440;
15906                                 }
15907                               else
15908                                 {
15909                                   /* 33222222222211111111110000000000
15910                                      10987654321098765432109876543210
15911                                      xx10110000xxxxxxxxxxxxxxxxxxxxxx
15912                                      stnp.  */
15913                                   return 973;
15914                                 }
15915                             }
15916                           else
15917                             {
15918                               if (((word >> 29) & 0x1) == 0)
15919                                 {
15920                                   if (((word >> 13) & 0x1) == 0)
15921                                     {
15922                                       if (((word >> 21) & 0x1) == 0)
15923                                         {
15924                                           /* 33222222222211111111110000000000
15925                                              10987654321098765432109876543210
15926                                              xx001101000xxxxxxx0xxxxxxxxxxxxx
15927                                              st1.  */
15928                                           return 456;
15929                                         }
15930                                       else
15931                                         {
15932                                           /* 33222222222211111111110000000000
15933                                              10987654321098765432109876543210
15934                                              xx001101001xxxxxxx0xxxxxxxxxxxxx
15935                                              st2.  */
15936                                           return 458;
15937                                         }
15938                                     }
15939                                   else
15940                                     {
15941                                       if (((word >> 21) & 0x1) == 0)
15942                                         {
15943                                           /* 33222222222211111111110000000000
15944                                              10987654321098765432109876543210
15945                                              xx001101000xxxxxxx1xxxxxxxxxxxxx
15946                                              st3.  */
15947                                           return 457;
15948                                         }
15949                                       else
15950                                         {
15951                                           /* 33222222222211111111110000000000
15952                                              10987654321098765432109876543210
15953                                              xx001101001xxxxxxx1xxxxxxxxxxxxx
15954                                              st4.  */
15955                                           return 459;
15956                                         }
15957                                     }
15958                                 }
15959                               else
15960                                 {
15961                                   /* 33222222222211111111110000000000
15962                                      10987654321098765432109876543210
15963                                      xx10110100xxxxxxxxxxxxxxxxxxxxxx
15964                                      stp.  */
15965                                   return 977;
15966                                 }
15967                             }
15968                         }
15969                       else
15970                         {
15971                           if (((word >> 29) & 0x1) == 0)
15972                             {
15973                               if (((word >> 21) & 0x1) == 0)
15974                                 {
15975                                   if (((word >> 24) & 0x1) == 0)
15976                                     {
15977                                       /* 33222222222211111111110000000000
15978                                          10987654321098765432109876543210
15979                                          xx001100100xxxxxxxxxxxxxxxxxxxxx
15980                                          st4.  */
15981                                       return 448;
15982                                     }
15983                                   else
15984                                     {
15985                                       if (((word >> 13) & 0x1) == 0)
15986                                         {
15987                                           /* 33222222222211111111110000000000
15988                                              10987654321098765432109876543210
15989                                              xx001101100xxxxxxx0xxxxxxxxxxxxx
15990                                              st1.  */
15991                                           return 468;
15992                                         }
15993                                       else
15994                                         {
15995                                           /* 33222222222211111111110000000000
15996                                              10987654321098765432109876543210
15997                                              xx001101100xxxxxxx1xxxxxxxxxxxxx
15998                                              st3.  */
15999                                           return 469;
16000                                         }
16001                                     }
16002                                 }
16003                               else
16004                                 {
16005                                   if (((word >> 13) & 0x1) == 0)
16006                                     {
16007                                       /* 33222222222211111111110000000000
16008                                          10987654321098765432109876543210
16009                                          xx00110x101xxxxxxx0xxxxxxxxxxxxx
16010                                          st2.  */
16011                                       return 470;
16012                                     }
16013                                   else
16014                                     {
16015                                       /* 33222222222211111111110000000000
16016                                          10987654321098765432109876543210
16017                                          xx00110x101xxxxxxx1xxxxxxxxxxxxx
16018                                          st4.  */
16019                                       return 471;
16020                                     }
16021                                 }
16022                             }
16023                           else
16024                             {
16025                               /* 33222222222211111111110000000000
16026                                  10987654321098765432109876543210
16027                                  xx10110x10xxxxxxxxxxxxxxxxxxxxxx
16028                                  stp.  */
16029                               return 983;
16030                             }
16031                         }
16032                     }
16033                   else
16034                     {
16035                       if (((word >> 23) & 0x1) == 0)
16036                         {
16037                           if (((word >> 24) & 0x1) == 0)
16038                             {
16039                               if (((word >> 29) & 0x1) == 0)
16040                                 {
16041                                   /* 33222222222211111111110000000000
16042                                      10987654321098765432109876543210
16043                                      xx00110001xxxxxxxxxxxxxxxxxxxxxx
16044                                      ld4.  */
16045                                   return 444;
16046                                 }
16047                               else
16048                                 {
16049                                   /* 33222222222211111111110000000000
16050                                      10987654321098765432109876543210
16051                                      xx10110001xxxxxxxxxxxxxxxxxxxxxx
16052                                      ldnp.  */
16053                                   return 974;
16054                                 }
16055                             }
16056                           else
16057                             {
16058                               if (((word >> 29) & 0x1) == 0)
16059                                 {
16060                                   if (((word >> 13) & 0x1) == 0)
16061                                     {
16062                                       if (((word >> 21) & 0x1) == 0)
16063                                         {
16064                                           /* 33222222222211111111110000000000
16065                                              10987654321098765432109876543210
16066                                              xx001101010xxxxxxx0xxxxxxxxxxxxx
16067                                              ld1.  */
16068                                           return 460;
16069                                         }
16070                                       else
16071                                         {
16072                                           /* 33222222222211111111110000000000
16073                                              10987654321098765432109876543210
16074                                              xx001101011xxxxxxx0xxxxxxxxxxxxx
16075                                              ld2.  */
16076                                           return 464;
16077                                         }
16078                                     }
16079                                   else
16080                                     {
16081                                       if (((word >> 21) & 0x1) == 0)
16082                                         {
16083                                           /* 33222222222211111111110000000000
16084                                              10987654321098765432109876543210
16085                                              xx001101010xxxxxxx1xxxxxxxxxxxxx
16086                                              ld3.  */
16087                                           return 461;
16088                                         }
16089                                       else
16090                                         {
16091                                           /* 33222222222211111111110000000000
16092                                              10987654321098765432109876543210
16093                                              xx001101011xxxxxxx1xxxxxxxxxxxxx
16094                                              ld4.  */
16095                                           return 465;
16096                                         }
16097                                     }
16098                                 }
16099                               else
16100                                 {
16101                                   /* 33222222222211111111110000000000
16102                                      10987654321098765432109876543210
16103                                      xx10110101xxxxxxxxxxxxxxxxxxxxxx
16104                                      ldp.  */
16105                                   return 978;
16106                                 }
16107                             }
16108                         }
16109                       else
16110                         {
16111                           if (((word >> 29) & 0x1) == 0)
16112                             {
16113                               if (((word >> 21) & 0x1) == 0)
16114                                 {
16115                                   if (((word >> 24) & 0x1) == 0)
16116                                     {
16117                                       /* 33222222222211111111110000000000
16118                                          10987654321098765432109876543210
16119                                          xx001100110xxxxxxxxxxxxxxxxxxxxx
16120                                          ld4.  */
16121                                       return 452;
16122                                     }
16123                                   else
16124                                     {
16125                                       if (((word >> 13) & 0x1) == 0)
16126                                         {
16127                                           /* 33222222222211111111110000000000
16128                                              10987654321098765432109876543210
16129                                              xx001101110xxxxxxx0xxxxxxxxxxxxx
16130                                              ld1.  */
16131                                           return 472;
16132                                         }
16133                                       else
16134                                         {
16135                                           /* 33222222222211111111110000000000
16136                                              10987654321098765432109876543210
16137                                              xx001101110xxxxxxx1xxxxxxxxxxxxx
16138                                              ld3.  */
16139                                           return 473;
16140                                         }
16141                                     }
16142                                 }
16143                               else
16144                                 {
16145                                   if (((word >> 13) & 0x1) == 0)
16146                                     {
16147                                       /* 33222222222211111111110000000000
16148                                          10987654321098765432109876543210
16149                                          xx00110x111xxxxxxx0xxxxxxxxxxxxx
16150                                          ld2.  */
16151                                       return 476;
16152                                     }
16153                                   else
16154                                     {
16155                                       /* 33222222222211111111110000000000
16156                                          10987654321098765432109876543210
16157                                          xx00110x111xxxxxxx1xxxxxxxxxxxxx
16158                                          ld4.  */
16159                                       return 477;
16160                                     }
16161                                 }
16162                             }
16163                           else
16164                             {
16165                               /* 33222222222211111111110000000000
16166                                  10987654321098765432109876543210
16167                                  xx10110x11xxxxxxxxxxxxxxxxxxxxxx
16168                                  ldp.  */
16169                               return 984;
16170                             }
16171                         }
16172                     }
16173                 }
16174               else
16175                 {
16176                   if (((word >> 24) & 0x1) == 0)
16177                     {
16178                       if (((word >> 29) & 0x1) == 0)
16179                         {
16180                           /* 33222222222211111111110000000000
16181                              10987654321098765432109876543210
16182                              xx011100xxxxxxxxxxxxxxxxxxxxxxxx
16183                              ldr.  */
16184                           return 988;
16185                         }
16186                       else
16187                         {
16188                           if (((word >> 10) & 0x1) == 0)
16189                             {
16190                               if (((word >> 11) & 0x1) == 0)
16191                                 {
16192                                   if (((word >> 22) & 0x1) == 0)
16193                                     {
16194                                       /* 33222222222211111111110000000000
16195                                          10987654321098765432109876543210
16196                                          xx111100x0xxxxxxxxxx00xxxxxxxxxx
16197                                          stur.  */
16198                                       return 925;
16199                                     }
16200                                   else
16201                                     {
16202                                       /* 33222222222211111111110000000000
16203                                          10987654321098765432109876543210
16204                                          xx111100x1xxxxxxxxxx00xxxxxxxxxx
16205                                          ldur.  */
16206                                       return 926;
16207                                     }
16208                                 }
16209                               else
16210                                 {
16211                                   if (((word >> 22) & 0x1) == 0)
16212                                     {
16213                                       /* 33222222222211111111110000000000
16214                                          10987654321098765432109876543210
16215                                          xx111100x0xxxxxxxxxx10xxxxxxxxxx
16216                                          str.  */
16217                                       return 904;
16218                                     }
16219                                   else
16220                                     {
16221                                       /* 33222222222211111111110000000000
16222                                          10987654321098765432109876543210
16223                                          xx111100x1xxxxxxxxxx10xxxxxxxxxx
16224                                          ldr.  */
16225                                       return 905;
16226                                     }
16227                                 }
16228                             }
16229                           else
16230                             {
16231                               if (((word >> 22) & 0x1) == 0)
16232                                 {
16233                                   /* 33222222222211111111110000000000
16234                                      10987654321098765432109876543210
16235                                      xx111100x0xxxxxxxxxxx1xxxxxxxxxx
16236                                      str.  */
16237                                   return 873;
16238                                 }
16239                               else
16240                                 {
16241                                   /* 33222222222211111111110000000000
16242                                      10987654321098765432109876543210
16243                                      xx111100x1xxxxxxxxxxx1xxxxxxxxxx
16244                                      ldr.  */
16245                                   return 874;
16246                                 }
16247                             }
16248                         }
16249                     }
16250                   else
16251                     {
16252                       if (((word >> 22) & 0x1) == 0)
16253                         {
16254                           /* 33222222222211111111110000000000
16255                              10987654321098765432109876543210
16256                              xxx11101x0xxxxxxxxxxxxxxxxxxxxxx
16257                              str.  */
16258                           return 892;
16259                         }
16260                       else
16261                         {
16262                           /* 33222222222211111111110000000000
16263                              10987654321098765432109876543210
16264                              xxx11101x1xxxxxxxxxxxxxxxxxxxxxx
16265                              ldr.  */
16266                           return 893;
16267                         }
16268                     }
16269                 }
16270             }
16271           else
16272             {
16273               if (((word >> 24) & 0x1) == 0)
16274                 {
16275                   if (((word >> 21) & 0x1) == 0)
16276                     {
16277                       if (((word >> 28) & 0x1) == 0)
16278                         {
16279                           if (((word >> 29) & 0x1) == 0)
16280                             {
16281                               if (((word >> 31) & 0x1) == 0)
16282                                 {
16283                                   if (((word >> 10) & 0x1) == 0)
16284                                     {
16285                                       if (((word >> 11) & 0x1) == 0)
16286                                         {
16287                                           if (((word >> 12) & 0x1) == 0)
16288                                             {
16289                                               /* 33222222222211111111110000000000
16290                                                  10987654321098765432109876543210
16291                                                  0x001110xx0xxxxxxxx000xxxxxxxxxx
16292                                                  tbl.  */
16293                                               return 420;
16294                                             }
16295                                           else
16296                                             {
16297                                               /* 33222222222211111111110000000000
16298                                                  10987654321098765432109876543210
16299                                                  0x001110xx0xxxxxxxx100xxxxxxxxxx
16300                                                  tbx.  */
16301                                               return 421;
16302                                             }
16303                                         }
16304                                       else
16305                                         {
16306                                           if (((word >> 12) & 0x1) == 0)
16307                                             {
16308                                               if (((word >> 14) & 0x1) == 0)
16309                                                 {
16310                                                   /* 33222222222211111111110000000000
16311                                                      10987654321098765432109876543210
16312                                                      0x001110xx0xxxxxx0x010xxxxxxxxxx
16313                                                      trn1.  */
16314                                                   return 263;
16315                                                 }
16316                                               else
16317                                                 {
16318                                                   /* 33222222222211111111110000000000
16319                                                      10987654321098765432109876543210
16320                                                      0x001110xx0xxxxxx1x010xxxxxxxxxx
16321                                                      trn2.  */
16322                                                   return 266;
16323                                                 }
16324                                             }
16325                                           else
16326                                             {
16327                                               if (((word >> 13) & 0x1) == 0)
16328                                                 {
16329                                                   if (((word >> 14) & 0x1) == 0)
16330                                                     {
16331                                                       /* 33222222222211111111110000000000
16332                                                          10987654321098765432109876543210
16333                                                          0x001110xx0xxxxxx00110xxxxxxxxxx
16334                                                          uzp1.  */
16335                                                       return 262;
16336                                                     }
16337                                                   else
16338                                                     {
16339                                                       /* 33222222222211111111110000000000
16340                                                          10987654321098765432109876543210
16341                                                          0x001110xx0xxxxxx10110xxxxxxxxxx
16342                                                          uzp2.  */
16343                                                       return 265;
16344                                                     }
16345                                                 }
16346                                               else
16347                                                 {
16348                                                   if (((word >> 14) & 0x1) == 0)
16349                                                     {
16350                                                       /* 33222222222211111111110000000000
16351                                                          10987654321098765432109876543210
16352                                                          0x001110xx0xxxxxx01110xxxxxxxxxx
16353                                                          zip1.  */
16354                                                       return 264;
16355                                                     }
16356                                                   else
16357                                                     {
16358                                                       /* 33222222222211111111110000000000
16359                                                          10987654321098765432109876543210
16360                                                          0x001110xx0xxxxxx11110xxxxxxxxxx
16361                                                          zip2.  */
16362                                                       return 267;
16363                                                     }
16364                                                 }
16365                                             }
16366                                         }
16367                                     }
16368                                   else
16369                                     {
16370                                       if (((word >> 11) & 0x1) == 0)
16371                                         {
16372                                           if (((word >> 12) & 0x1) == 0)
16373                                             {
16374                                               if (((word >> 13) & 0x1) == 0)
16375                                                 {
16376                                                   if (((word >> 22) & 0x1) == 0)
16377                                                     {
16378                                                       /* 33222222222211111111110000000000
16379                                                          10987654321098765432109876543210
16380                                                          0x001110x00xxxxxxx0001xxxxxxxxxx
16381                                                          dup.  */
16382                                                       return 149;
16383                                                     }
16384                                                   else
16385                                                     {
16386                                                       if (((word >> 23) & 0x1) == 0)
16387                                                         {
16388                                                           /* 33222222222211111111110000000000
16389                                                              10987654321098765432109876543210
16390                                                              0x001110010xxxxxxx0001xxxxxxxxxx
16391                                                              fmaxnm.  */
16392                                                           return 292;
16393                                                         }
16394                                                       else
16395                                                         {
16396                                                           /* 33222222222211111111110000000000
16397                                                              10987654321098765432109876543210
16398                                                              0x001110110xxxxxxx0001xxxxxxxxxx
16399                                                              fminnm.  */
16400                                                           return 308;
16401                                                         }
16402                                                     }
16403                                                 }
16404                                               else
16405                                                 {
16406                                                   if (((word >> 15) & 0x1) == 0)
16407                                                     {
16408                                                       /* 33222222222211111111110000000000
16409                                                          10987654321098765432109876543210
16410                                                          0x001110xx0xxxxx0x1001xxxxxxxxxx
16411                                                          fcmeq.  */
16412                                                       return 300;
16413                                                     }
16414                                                   else
16415                                                     {
16416                                                       /* 33222222222211111111110000000000
16417                                                          10987654321098765432109876543210
16418                                                          0x001110xx0xxxxx1x1001xxxxxxxxxx
16419                                                          smmla.  */
16420                                                       return 2416;
16421                                                     }
16422                                                 }
16423                                             }
16424                                           else
16425                                             {
16426                                               if (((word >> 13) & 0x1) == 0)
16427                                                 {
16428                                                   if (((word >> 15) & 0x1) == 0)
16429                                                     {
16430                                                       if (((word >> 23) & 0x1) == 0)
16431                                                         {
16432                                                           /* 33222222222211111111110000000000
16433                                                              10987654321098765432109876543210
16434                                                              0x0011100x0xxxxx0x0101xxxxxxxxxx
16435                                                              fadd.  */
16436                                                           return 296;
16437                                                         }
16438                                                       else
16439                                                         {
16440                                                           /* 33222222222211111111110000000000
16441                                                              10987654321098765432109876543210
16442                                                              0x0011101x0xxxxx0x0101xxxxxxxxxx
16443                                                              fsub.  */
16444                                                           return 312;
16445                                                         }
16446                                                     }
16447                                                   else
16448                                                     {
16449                                                       /* 33222222222211111111110000000000
16450                                                          10987654321098765432109876543210
16451                                                          0x001110xx0xxxxx1x0101xxxxxxxxxx
16452                                                          sdot.  */
16453                                                       return 2342;
16454                                                     }
16455                                                 }
16456                                               else
16457                                                 {
16458                                                   if (((word >> 23) & 0x1) == 0)
16459                                                     {
16460                                                       /* 33222222222211111111110000000000
16461                                                          10987654321098765432109876543210
16462                                                          0x0011100x0xxxxxxx1101xxxxxxxxxx
16463                                                          fmax.  */
16464                                                       return 302;
16465                                                     }
16466                                                   else
16467                                                     {
16468                                                       /* 33222222222211111111110000000000
16469                                                          10987654321098765432109876543210
16470                                                          0x0011101x0xxxxxxx1101xxxxxxxxxx
16471                                                          fmin.  */
16472                                                       return 314;
16473                                                     }
16474                                                 }
16475                                             }
16476                                         }
16477                                       else
16478                                         {
16479                                           if (((word >> 12) & 0x1) == 0)
16480                                             {
16481                                               if (((word >> 13) & 0x1) == 0)
16482                                                 {
16483                                                   if (((word >> 22) & 0x1) == 0)
16484                                                     {
16485                                                       /* 33222222222211111111110000000000
16486                                                          10987654321098765432109876543210
16487                                                          0x001110x00xxxxxxx0011xxxxxxxxxx
16488                                                          dup.  */
16489                                                       return 150;
16490                                                     }
16491                                                   else
16492                                                     {
16493                                                       if (((word >> 23) & 0x1) == 0)
16494                                                         {
16495                                                           /* 33222222222211111111110000000000
16496                                                              10987654321098765432109876543210
16497                                                              0x001110010xxxxxxx0011xxxxxxxxxx
16498                                                              fmla.  */
16499                                                           return 294;
16500                                                         }
16501                                                       else
16502                                                         {
16503                                                           /* 33222222222211111111110000000000
16504                                                              10987654321098765432109876543210
16505                                                              0x001110110xxxxxxx0011xxxxxxxxxx
16506                                                              fmls.  */
16507                                                           return 310;
16508                                                         }
16509                                                     }
16510                                                 }
16511                                               else
16512                                                 {
16513                                                   if (((word >> 15) & 0x1) == 0)
16514                                                     {
16515                                                       /* 33222222222211111111110000000000
16516                                                          10987654321098765432109876543210
16517                                                          0x001110xx0xxxxx0x1011xxxxxxxxxx
16518                                                          smov.  */
16519                                                       return 151;
16520                                                     }
16521                                                   else
16522                                                     {
16523                                                       /* 33222222222211111111110000000000
16524                                                          10987654321098765432109876543210
16525                                                          0x001110xx0xxxxx1x1011xxxxxxxxxx
16526                                                          usmmla.  */
16527                                                       return 2418;
16528                                                     }
16529                                                 }
16530                                             }
16531                                           else
16532                                             {
16533                                               if (((word >> 13) & 0x1) == 0)
16534                                                 {
16535                                                   if (((word >> 15) & 0x1) == 0)
16536                                                     {
16537                                                       if (((word >> 22) & 0x1) == 0)
16538                                                         {
16539                                                           /* 33222222222211111111110000000000
16540                                                              10987654321098765432109876543210
16541                                                              0x001110x00xxxxx0x0111xxxxxxxxxx
16542                                                              ins.  */
16543                                                           return 154;
16544                                                         }
16545                                                       else
16546                                                         {
16547                                                           /* 33222222222211111111110000000000
16548                                                              10987654321098765432109876543210
16549                                                              0x001110x10xxxxx0x0111xxxxxxxxxx
16550                                                              fmulx.  */
16551                                                           return 298;
16552                                                         }
16553                                                     }
16554                                                   else
16555                                                     {
16556                                                       /* 33222222222211111111110000000000
16557                                                          10987654321098765432109876543210
16558                                                          0x001110xx0xxxxx1x0111xxxxxxxxxx
16559                                                          usdot.  */
16560                                                       return 2419;
16561                                                     }
16562                                                 }
16563                                               else
16564                                                 {
16565                                                   if (((word >> 22) & 0x1) == 0)
16566                                                     {
16567                                                       /* 33222222222211111111110000000000
16568                                                          10987654321098765432109876543210
16569                                                          0x001110x00xxxxxxx1111xxxxxxxxxx
16570                                                          umov.  */
16571                                                       return 152;
16572                                                     }
16573                                                   else
16574                                                     {
16575                                                       if (((word >> 23) & 0x1) == 0)
16576                                                         {
16577                                                           /* 33222222222211111111110000000000
16578                                                              10987654321098765432109876543210
16579                                                              0x001110010xxxxxxx1111xxxxxxxxxx
16580                                                              frecps.  */
16581                                                           return 304;
16582                                                         }
16583                                                       else
16584                                                         {
16585                                                           /* 33222222222211111111110000000000
16586                                                              10987654321098765432109876543210
16587                                                              0x001110110xxxxxxx1111xxxxxxxxxx
16588                                                              frsqrts.  */
16589                                                           return 316;
16590                                                         }
16591                                                     }
16592                                                 }
16593                                             }
16594                                         }
16595                                     }
16596                                 }
16597                               else
16598                                 {
16599                                   if (((word >> 22) & 0x1) == 0)
16600                                     {
16601                                       if (((word >> 23) & 0x1) == 0)
16602                                         {
16603                                           /* 33222222222211111111110000000000
16604                                              10987654321098765432109876543210
16605                                              1x001110000xxxxxxxxxxxxxxxxxxxxx
16606                                              eor3.  */
16607                                           return 2349;
16608                                         }
16609                                       else
16610                                         {
16611                                           /* 33222222222211111111110000000000
16612                                              10987654321098765432109876543210
16613                                              1x001110100xxxxxxxxxxxxxxxxxxxxx
16614                                              xar.  */
16615                                           return 2351;
16616                                         }
16617                                     }
16618                                   else
16619                                     {
16620                                       if (((word >> 15) & 0x1) == 0)
16621                                         {
16622                                           /* 33222222222211111111110000000000
16623                                              10987654321098765432109876543210
16624                                              1x001110x10xxxxx0xxxxxxxxxxxxxxx
16625                                              sm3ss1.  */
16626                                           return 2353;
16627                                         }
16628                                       else
16629                                         {
16630                                           if (((word >> 10) & 0x1) == 0)
16631                                             {
16632                                               if (((word >> 11) & 0x1) == 0)
16633                                                 {
16634                                                   if (((word >> 23) & 0x1) == 0)
16635                                                     {
16636                                                       /* 33222222222211111111110000000000
16637                                                          10987654321098765432109876543210
16638                                                          1x001110010xxxxx1xxx00xxxxxxxxxx
16639                                                          sm3tt1a.  */
16640                                                       return 2354;
16641                                                     }
16642                                                   else
16643                                                     {
16644                                                       /* 33222222222211111111110000000000
16645                                                          10987654321098765432109876543210
16646                                                          1x001110110xxxxx1xxx00xxxxxxxxxx
16647                                                          sha512su0.  */
16648                                                       return 2347;
16649                                                     }
16650                                                 }
16651                                               else
16652                                                 {
16653                                                   /* 33222222222211111111110000000000
16654                                                      10987654321098765432109876543210
16655                                                      1x001110x10xxxxx1xxx10xxxxxxxxxx
16656                                                      sm3tt2a.  */
16657                                                   return 2356;
16658                                                 }
16659                                             }
16660                                           else
16661                                             {
16662                                               if (((word >> 11) & 0x1) == 0)
16663                                                 {
16664                                                   if (((word >> 23) & 0x1) == 0)
16665                                                     {
16666                                                       /* 33222222222211111111110000000000
16667                                                          10987654321098765432109876543210
16668                                                          1x001110010xxxxx1xxx01xxxxxxxxxx
16669                                                          sm3tt1b.  */
16670                                                       return 2355;
16671                                                     }
16672                                                   else
16673                                                     {
16674                                                       /* 33222222222211111111110000000000
16675                                                          10987654321098765432109876543210
16676                                                          1x001110110xxxxx1xxx01xxxxxxxxxx
16677                                                          sm4e.  */
16678                                                       return 2360;
16679                                                     }
16680                                                 }
16681                                               else
16682                                                 {
16683                                                   /* 33222222222211111111110000000000
16684                                                      10987654321098765432109876543210
16685                                                      1x001110x10xxxxx1xxx11xxxxxxxxxx
16686                                                      sm3tt2b.  */
16687                                                   return 2357;
16688                                                 }
16689                                             }
16690                                         }
16691                                     }
16692                                 }
16693                             }
16694                           else
16695                             {
16696                               if (((word >> 10) & 0x1) == 0)
16697                                 {
16698                                   /* 33222222222211111111110000000000
16699                                      10987654321098765432109876543210
16700                                      xx101110xx0xxxxxxxxxx0xxxxxxxxxx
16701                                      ext.  */
16702                                   return 132;
16703                                 }
16704                               else
16705                                 {
16706                                   if (((word >> 15) & 0x1) == 0)
16707                                     {
16708                                       if (((word >> 22) & 0x1) == 0)
16709                                         {
16710                                           /* 33222222222211111111110000000000
16711                                              10987654321098765432109876543210
16712                                              xx101110x00xxxxx0xxxx1xxxxxxxxxx
16713                                              ins.  */
16714                                           return 156;
16715                                         }
16716                                       else
16717                                         {
16718                                           if (((word >> 11) & 0x1) == 0)
16719                                             {
16720                                               if (((word >> 12) & 0x1) == 0)
16721                                                 {
16722                                                   if (((word >> 13) & 0x1) == 0)
16723                                                     {
16724                                                       if (((word >> 23) & 0x1) == 0)
16725                                                         {
16726                                                           /* 33222222222211111111110000000000
16727                                                              10987654321098765432109876543210
16728                                                              xx101110010xxxxx0x0001xxxxxxxxxx
16729                                                              fmaxnmp.  */
16730                                                           return 343;
16731                                                         }
16732                                                       else
16733                                                         {
16734                                                           /* 33222222222211111111110000000000
16735                                                              10987654321098765432109876543210
16736                                                              xx101110110xxxxx0x0001xxxxxxxxxx
16737                                                              fminnmp.  */
16738                                                           return 359;
16739                                                         }
16740                                                     }
16741                                                   else
16742                                                     {
16743                                                       if (((word >> 23) & 0x1) == 0)
16744                                                         {
16745                                                           /* 33222222222211111111110000000000
16746                                                              10987654321098765432109876543210
16747                                                              xx101110010xxxxx0x1001xxxxxxxxxx
16748                                                              fcmge.  */
16749                                                           return 349;
16750                                                         }
16751                                                       else
16752                                                         {
16753                                                           /* 33222222222211111111110000000000
16754                                                              10987654321098765432109876543210
16755                                                              xx101110110xxxxx0x1001xxxxxxxxxx
16756                                                              fcmgt.  */
16757                                                           return 363;
16758                                                         }
16759                                                     }
16760                                                 }
16761                                               else
16762                                                 {
16763                                                   if (((word >> 13) & 0x1) == 0)
16764                                                     {
16765                                                       if (((word >> 23) & 0x1) == 0)
16766                                                         {
16767                                                           /* 33222222222211111111110000000000
16768                                                              10987654321098765432109876543210
16769                                                              xx101110010xxxxx0x0101xxxxxxxxxx
16770                                                              faddp.  */
16771                                                           return 345;
16772                                                         }
16773                                                       else
16774                                                         {
16775                                                           /* 33222222222211111111110000000000
16776                                                              10987654321098765432109876543210
16777                                                              xx101110110xxxxx0x0101xxxxxxxxxx
16778                                                              fabd.  */
16779                                                           return 361;
16780                                                         }
16781                                                     }
16782                                                   else
16783                                                     {
16784                                                       if (((word >> 23) & 0x1) == 0)
16785                                                         {
16786                                                           /* 33222222222211111111110000000000
16787                                                              10987654321098765432109876543210
16788                                                              xx101110010xxxxx0x1101xxxxxxxxxx
16789                                                              fmaxp.  */
16790                                                           return 353;
16791                                                         }
16792                                                       else
16793                                                         {
16794                                                           /* 33222222222211111111110000000000
16795                                                              10987654321098765432109876543210
16796                                                              xx101110110xxxxx0x1101xxxxxxxxxx
16797                                                              fminp.  */
16798                                                           return 367;
16799                                                         }
16800                                                     }
16801                                                 }
16802                                             }
16803                                           else
16804                                             {
16805                                               if (((word >> 12) & 0x1) == 0)
16806                                                 {
16807                                                   if (((word >> 23) & 0x1) == 0)
16808                                                     {
16809                                                       /* 33222222222211111111110000000000
16810                                                          10987654321098765432109876543210
16811                                                          xx101110010xxxxx0xx011xxxxxxxxxx
16812                                                          facge.  */
16813                                                       return 351;
16814                                                     }
16815                                                   else
16816                                                     {
16817                                                       /* 33222222222211111111110000000000
16818                                                          10987654321098765432109876543210
16819                                                          xx101110110xxxxx0xx011xxxxxxxxxx
16820                                                          facgt.  */
16821                                                       return 365;
16822                                                     }
16823                                                 }
16824                                               else
16825                                                 {
16826                                                   if (((word >> 13) & 0x1) == 0)
16827                                                     {
16828                                                       /* 33222222222211111111110000000000
16829                                                          10987654321098765432109876543210
16830                                                          xx101110x10xxxxx0x0111xxxxxxxxxx
16831                                                          fmul.  */
16832                                                       return 347;
16833                                                     }
16834                                                   else
16835                                                     {
16836                                                       /* 33222222222211111111110000000000
16837                                                          10987654321098765432109876543210
16838                                                          xx101110x10xxxxx0x1111xxxxxxxxxx
16839                                                          fdiv.  */
16840                                                       return 355;
16841                                                     }
16842                                                 }
16843                                             }
16844                                         }
16845                                     }
16846                                   else
16847                                     {
16848                                       if (((word >> 13) & 0x1) == 0)
16849                                         {
16850                                           if (((word >> 14) & 0x1) == 0)
16851                                             {
16852                                               if (((word >> 11) & 0x1) == 0)
16853                                                 {
16854                                                   if (((word >> 12) & 0x1) == 0)
16855                                                     {
16856                                                       /* 33222222222211111111110000000000
16857                                                          10987654321098765432109876543210
16858                                                          xx101110xx0xxxxx100001xxxxxxxxxx
16859                                                          sqrdmlah.  */
16860                                                       return 370;
16861                                                     }
16862                                                   else
16863                                                     {
16864                                                       /* 33222222222211111111110000000000
16865                                                          10987654321098765432109876543210
16866                                                          xx101110xx0xxxxx100101xxxxxxxxxx
16867                                                          udot.  */
16868                                                       return 2341;
16869                                                     }
16870                                                 }
16871                                               else
16872                                                 {
16873                                                   /* 33222222222211111111110000000000
16874                                                      10987654321098765432109876543210
16875                                                      xx101110xx0xxxxx100x11xxxxxxxxxx
16876                                                      sqrdmlsh.  */
16877                                                   return 371;
16878                                                 }
16879                                             }
16880                                           else
16881                                             {
16882                                               /* 33222222222211111111110000000000
16883                                                  10987654321098765432109876543210
16884                                                  xx101110xx0xxxxx110xx1xxxxxxxxxx
16885                                                  fcmla.  */
16886                                               return 372;
16887                                             }
16888                                         }
16889                                       else
16890                                         {
16891                                           if (((word >> 11) & 0x1) == 0)
16892                                             {
16893                                               if (((word >> 14) & 0x1) == 0)
16894                                                 {
16895                                                   /* 33222222222211111111110000000000
16896                                                      10987654321098765432109876543210
16897                                                      xx101110xx0xxxxx101x01xxxxxxxxxx
16898                                                      ummla.  */
16899                                                   return 2417;
16900                                                 }
16901                                               else
16902                                                 {
16903                                                   /* 33222222222211111111110000000000
16904                                                      10987654321098765432109876543210
16905                                                      xx101110xx0xxxxx111x01xxxxxxxxxx
16906                                                      fcadd.  */
16907                                                   return 373;
16908                                                 }
16909                                             }
16910                                           else
16911                                             {
16912                                               if (((word >> 12) & 0x1) == 0)
16913                                                 {
16914                                                   /* 33222222222211111111110000000000
16915                                                      10987654321098765432109876543210
16916                                                      xx101110xx0xxxxx1x1011xxxxxxxxxx
16917                                                      bfmmla.  */
16918                                                   return 2433;
16919                                                 }
16920                                               else
16921                                                 {
16922                                                   if (((word >> 23) & 0x1) == 0)
16923                                                     {
16924                                                       /* 33222222222211111111110000000000
16925                                                          10987654321098765432109876543210
16926                                                          xx1011100x0xxxxx1x1111xxxxxxxxxx
16927                                                          bfdot.  */
16928                                                       return 2431;
16929                                                     }
16930                                                   else
16931                                                     {
16932                                                       if (((word >> 30) & 0x1) == 0)
16933                                                         {
16934                                                           /* 33222222222211111111110000000000
16935                                                              10987654321098765432109876543210
16936                                                              x01011101x0xxxxx1x1111xxxxxxxxxx
16937                                                              bfmlalb.  */
16938                                                           return 2438;
16939                                                         }
16940                                                       else
16941                                                         {
16942                                                           /* 33222222222211111111110000000000
16943                                                              10987654321098765432109876543210
16944                                                              x11011101x0xxxxx1x1111xxxxxxxxxx
16945                                                              bfmlalt.  */
16946                                                           return 2437;
16947                                                         }
16948                                                     }
16949                                                 }
16950                                             }
16951                                         }
16952                                     }
16953                                 }
16954                             }
16955                         }
16956                       else
16957                         {
16958                           if (((word >> 29) & 0x1) == 0)
16959                             {
16960                               if (((word >> 30) & 0x1) == 0)
16961                                 {
16962                                   if (((word >> 16) & 0x1) == 0)
16963                                     {
16964                                       if (((word >> 17) & 0x1) == 0)
16965                                         {
16966                                           /* 33222222222211111111110000000000
16967                                              10987654321098765432109876543210
16968                                              x0011110xx0xxx00xxxxxxxxxxxxxxxx
16969                                              fcvtzs.  */
16970                                           return 764;
16971                                         }
16972                                       else
16973                                         {
16974                                           /* 33222222222211111111110000000000
16975                                              10987654321098765432109876543210
16976                                              x0011110xx0xxx10xxxxxxxxxxxxxxxx
16977                                              scvtf.  */
16978                                           return 760;
16979                                         }
16980                                     }
16981                                   else
16982                                     {
16983                                       if (((word >> 17) & 0x1) == 0)
16984                                         {
16985                                           /* 33222222222211111111110000000000
16986                                              10987654321098765432109876543210
16987                                              x0011110xx0xxx01xxxxxxxxxxxxxxxx
16988                                              fcvtzu.  */
16989                                           return 766;
16990                                         }
16991                                       else
16992                                         {
16993                                           /* 33222222222211111111110000000000
16994                                              10987654321098765432109876543210
16995                                              x0011110xx0xxx11xxxxxxxxxxxxxxxx
16996                                              ucvtf.  */
16997                                           return 762;
16998                                         }
16999                                     }
17000                                 }
17001                               else
17002                                 {
17003                                   if (((word >> 10) & 0x1) == 0)
17004                                     {
17005                                       if (((word >> 12) & 0x1) == 0)
17006                                         {
17007                                           if (((word >> 13) & 0x1) == 0)
17008                                             {
17009                                               if (((word >> 14) & 0x1) == 0)
17010                                                 {
17011                                                   /* 33222222222211111111110000000000
17012                                                      10987654321098765432109876543210
17013                                                      x1011110xx0xxxxxx000x0xxxxxxxxxx
17014                                                      sha1c.  */
17015                                                   return 678;
17016                                                 }
17017                                               else
17018                                                 {
17019                                                   /* 33222222222211111111110000000000
17020                                                      10987654321098765432109876543210
17021                                                      x1011110xx0xxxxxx100x0xxxxxxxxxx
17022                                                      sha256h.  */
17023                                                   return 682;
17024                                                 }
17025                                             }
17026                                           else
17027                                             {
17028                                               if (((word >> 14) & 0x1) == 0)
17029                                                 {
17030                                                   /* 33222222222211111111110000000000
17031                                                      10987654321098765432109876543210
17032                                                      x1011110xx0xxxxxx010x0xxxxxxxxxx
17033                                                      sha1m.  */
17034                                                   return 680;
17035                                                 }
17036                                               else
17037                                                 {
17038                                                   /* 33222222222211111111110000000000
17039                                                      10987654321098765432109876543210
17040                                                      x1011110xx0xxxxxx110x0xxxxxxxxxx
17041                                                      sha256su1.  */
17042                                                   return 684;
17043                                                 }
17044                                             }
17045                                         }
17046                                       else
17047                                         {
17048                                           if (((word >> 13) & 0x1) == 0)
17049                                             {
17050                                               if (((word >> 14) & 0x1) == 0)
17051                                                 {
17052                                                   /* 33222222222211111111110000000000
17053                                                      10987654321098765432109876543210
17054                                                      x1011110xx0xxxxxx001x0xxxxxxxxxx
17055                                                      sha1p.  */
17056                                                   return 679;
17057                                                 }
17058                                               else
17059                                                 {
17060                                                   /* 33222222222211111111110000000000
17061                                                      10987654321098765432109876543210
17062                                                      x1011110xx0xxxxxx101x0xxxxxxxxxx
17063                                                      sha256h2.  */
17064                                                   return 683;
17065                                                 }
17066                                             }
17067                                           else
17068                                             {
17069                                               /* 33222222222211111111110000000000
17070                                                  10987654321098765432109876543210
17071                                                  x1011110xx0xxxxxxx11x0xxxxxxxxxx
17072                                                  sha1su0.  */
17073                                               return 681;
17074                                             }
17075                                         }
17076                                     }
17077                                   else
17078                                     {
17079                                       if (((word >> 11) & 0x1) == 0)
17080                                         {
17081                                           if (((word >> 13) & 0x1) == 0)
17082                                             {
17083                                               /* 33222222222211111111110000000000
17084                                                  10987654321098765432109876543210
17085                                                  x1011110xx0xxxxxxx0x01xxxxxxxxxx
17086                                                  dup.  */
17087                                               return 535;
17088                                             }
17089                                           else
17090                                             {
17091                                               /* 33222222222211111111110000000000
17092                                                  10987654321098765432109876543210
17093                                                  x1011110xx0xxxxxxx1x01xxxxxxxxxx
17094                                                  fcmeq.  */
17095                                               return 556;
17096                                             }
17097                                         }
17098                                       else
17099                                         {
17100                                           if (((word >> 13) & 0x1) == 0)
17101                                             {
17102                                               /* 33222222222211111111110000000000
17103                                                  10987654321098765432109876543210
17104                                                  x1011110xx0xxxxxxx0x11xxxxxxxxxx
17105                                                  fmulx.  */
17106                                               return 554;
17107                                             }
17108                                           else
17109                                             {
17110                                               if (((word >> 23) & 0x1) == 0)
17111                                                 {
17112                                                   /* 33222222222211111111110000000000
17113                                                      10987654321098765432109876543210
17114                                                      x10111100x0xxxxxxx1x11xxxxxxxxxx
17115                                                      frecps.  */
17116                                                   return 558;
17117                                                 }
17118                                               else
17119                                                 {
17120                                                   /* 33222222222211111111110000000000
17121                                                      10987654321098765432109876543210
17122                                                      x10111101x0xxxxxxx1x11xxxxxxxxxx
17123                                                      frsqrts.  */
17124                                                   return 560;
17125                                                 }
17126                                             }
17127                                         }
17128                                     }
17129                                 }
17130                             }
17131                           else
17132                             {
17133                               if (((word >> 11) & 0x1) == 0)
17134                                 {
17135                                   if (((word >> 12) & 0x1) == 0)
17136                                     {
17137                                       if (((word >> 13) & 0x1) == 0)
17138                                         {
17139                                           /* 33222222222211111111110000000000
17140                                              10987654321098765432109876543210
17141                                              xx111110xx0xxxxxxx000xxxxxxxxxxx
17142                                              sqrdmlah.  */
17143                                           return 588;
17144                                         }
17145                                       else
17146                                         {
17147                                           if (((word >> 23) & 0x1) == 0)
17148                                             {
17149                                               /* 33222222222211111111110000000000
17150                                                  10987654321098765432109876543210
17151                                                  xx1111100x0xxxxxxx100xxxxxxxxxxx
17152                                                  fcmge.  */
17153                                               return 573;
17154                                             }
17155                                           else
17156                                             {
17157                                               /* 33222222222211111111110000000000
17158                                                  10987654321098765432109876543210
17159                                                  xx1111101x0xxxxxxx100xxxxxxxxxxx
17160                                                  fcmgt.  */
17161                                               return 579;
17162                                             }
17163                                         }
17164                                     }
17165                                   else
17166                                     {
17167                                       /* 33222222222211111111110000000000
17168                                          10987654321098765432109876543210
17169                                          xx111110xx0xxxxxxxx10xxxxxxxxxxx
17170                                          fabd.  */
17171                                       return 577;
17172                                     }
17173                                 }
17174                               else
17175                                 {
17176                                   if (((word >> 13) & 0x1) == 0)
17177                                     {
17178                                       /* 33222222222211111111110000000000
17179                                          10987654321098765432109876543210
17180                                          xx111110xx0xxxxxxx0x1xxxxxxxxxxx
17181                                          sqrdmlsh.  */
17182                                       return 589;
17183                                     }
17184                                   else
17185                                     {
17186                                       if (((word >> 23) & 0x1) == 0)
17187                                         {
17188                                           /* 33222222222211111111110000000000
17189                                              10987654321098765432109876543210
17190                                              xx1111100x0xxxxxxx1x1xxxxxxxxxxx
17191                                              facge.  */
17192                                           return 575;
17193                                         }
17194                                       else
17195                                         {
17196                                           /* 33222222222211111111110000000000
17197                                              10987654321098765432109876543210
17198                                              xx1111101x0xxxxxxx1x1xxxxxxxxxxx
17199                                              facgt.  */
17200                                           return 581;
17201                                         }
17202                                     }
17203                                 }
17204                             }
17205                         }
17206                     }
17207                   else
17208                     {
17209                       if (((word >> 28) & 0x1) == 0)
17210                         {
17211                           if (((word >> 15) & 0x1) == 0)
17212                             {
17213                               if (((word >> 29) & 0x1) == 0)
17214                                 {
17215                                   if (((word >> 31) & 0x1) == 0)
17216                                     {
17217                                       if (((word >> 10) & 0x1) == 0)
17218                                         {
17219                                           if (((word >> 11) & 0x1) == 0)
17220                                             {
17221                                               if (((word >> 12) & 0x1) == 0)
17222                                                 {
17223                                                   if (((word >> 13) & 0x1) == 0)
17224                                                     {
17225                                                       if (((word >> 14) & 0x1) == 0)
17226                                                         {
17227                                                           if (((word >> 30) & 0x1) == 0)
17228                                                             {
17229                                                               /* 33222222222211111111110000000000
17230                                                                  10987654321098765432109876543210
17231                                                                  00001110xx1xxxxx000000xxxxxxxxxx
17232                                                                  saddl.  */
17233                                                               return 44;
17234                                                             }
17235                                                           else
17236                                                             {
17237                                                               /* 33222222222211111111110000000000
17238                                                                  10987654321098765432109876543210
17239                                                                  01001110xx1xxxxx000000xxxxxxxxxx
17240                                                                  saddl2.  */
17241                                                               return 45;
17242                                                             }
17243                                                         }
17244                                                       else
17245                                                         {
17246                                                           if (((word >> 30) & 0x1) == 0)
17247                                                             {
17248                                                               /* 33222222222211111111110000000000
17249                                                                  10987654321098765432109876543210
17250                                                                  00001110xx1xxxxx010000xxxxxxxxxx
17251                                                                  addhn.  */
17252                                                               return 52;
17253                                                             }
17254                                                           else
17255                                                             {
17256                                                               /* 33222222222211111111110000000000
17257                                                                  10987654321098765432109876543210
17258                                                                  01001110xx1xxxxx010000xxxxxxxxxx
17259                                                                  addhn2.  */
17260                                                               return 53;
17261                                                             }
17262                                                         }
17263                                                     }
17264                                                   else
17265                                                     {
17266                                                       if (((word >> 14) & 0x1) == 0)
17267                                                         {
17268                                                           if (((word >> 30) & 0x1) == 0)
17269                                                             {
17270                                                               /* 33222222222211111111110000000000
17271                                                                  10987654321098765432109876543210
17272                                                                  00001110xx1xxxxx001000xxxxxxxxxx
17273                                                                  ssubl.  */
17274                                                               return 48;
17275                                                             }
17276                                                           else
17277                                                             {
17278                                                               /* 33222222222211111111110000000000
17279                                                                  10987654321098765432109876543210
17280                                                                  01001110xx1xxxxx001000xxxxxxxxxx
17281                                                                  ssubl2.  */
17282                                                               return 49;
17283                                                             }
17284                                                         }
17285                                                       else
17286                                                         {
17287                                                           if (((word >> 30) & 0x1) == 0)
17288                                                             {
17289                                                               /* 33222222222211111111110000000000
17290                                                                  10987654321098765432109876543210
17291                                                                  00001110xx1xxxxx011000xxxxxxxxxx
17292                                                                  subhn.  */
17293                                                               return 56;
17294                                                             }
17295                                                           else
17296                                                             {
17297                                                               /* 33222222222211111111110000000000
17298                                                                  10987654321098765432109876543210
17299                                                                  01001110xx1xxxxx011000xxxxxxxxxx
17300                                                                  subhn2.  */
17301                                                               return 57;
17302                                                             }
17303                                                         }
17304                                                     }
17305                                                 }
17306                                               else
17307                                                 {
17308                                                   if (((word >> 13) & 0x1) == 0)
17309                                                     {
17310                                                       if (((word >> 14) & 0x1) == 0)
17311                                                         {
17312                                                           if (((word >> 30) & 0x1) == 0)
17313                                                             {
17314                                                               /* 33222222222211111111110000000000
17315                                                                  10987654321098765432109876543210
17316                                                                  00001110xx1xxxxx000100xxxxxxxxxx
17317                                                                  saddw.  */
17318                                                               return 46;
17319                                                             }
17320                                                           else
17321                                                             {
17322                                                               /* 33222222222211111111110000000000
17323                                                                  10987654321098765432109876543210
17324                                                                  01001110xx1xxxxx000100xxxxxxxxxx
17325                                                                  saddw2.  */
17326                                                               return 47;
17327                                                             }
17328                                                         }
17329                                                       else
17330                                                         {
17331                                                           if (((word >> 30) & 0x1) == 0)
17332                                                             {
17333                                                               /* 33222222222211111111110000000000
17334                                                                  10987654321098765432109876543210
17335                                                                  00001110xx1xxxxx010100xxxxxxxxxx
17336                                                                  sabal.  */
17337                                                               return 54;
17338                                                             }
17339                                                           else
17340                                                             {
17341                                                               /* 33222222222211111111110000000000
17342                                                                  10987654321098765432109876543210
17343                                                                  01001110xx1xxxxx010100xxxxxxxxxx
17344                                                                  sabal2.  */
17345                                                               return 55;
17346                                                             }
17347                                                         }
17348                                                     }
17349                                                   else
17350                                                     {
17351                                                       if (((word >> 14) & 0x1) == 0)
17352                                                         {
17353                                                           if (((word >> 30) & 0x1) == 0)
17354                                                             {
17355                                                               /* 33222222222211111111110000000000
17356                                                                  10987654321098765432109876543210
17357                                                                  00001110xx1xxxxx001100xxxxxxxxxx
17358                                                                  ssubw.  */
17359                                                               return 50;
17360                                                             }
17361                                                           else
17362                                                             {
17363                                                               /* 33222222222211111111110000000000
17364                                                                  10987654321098765432109876543210
17365                                                                  01001110xx1xxxxx001100xxxxxxxxxx
17366                                                                  ssubw2.  */
17367                                                               return 51;
17368                                                             }
17369                                                         }
17370                                                       else
17371                                                         {
17372                                                           if (((word >> 30) & 0x1) == 0)
17373                                                             {
17374                                                               /* 33222222222211111111110000000000
17375                                                                  10987654321098765432109876543210
17376                                                                  00001110xx1xxxxx011100xxxxxxxxxx
17377                                                                  sabdl.  */
17378                                                               return 58;
17379                                                             }
17380                                                           else
17381                                                             {
17382                                                               /* 33222222222211111111110000000000
17383                                                                  10987654321098765432109876543210
17384                                                                  01001110xx1xxxxx011100xxxxxxxxxx
17385                                                                  sabdl2.  */
17386                                                               return 59;
17387                                                             }
17388                                                         }
17389                                                     }
17390                                                 }
17391                                             }
17392                                           else
17393                                             {
17394                                               if (((word >> 12) & 0x1) == 0)
17395                                                 {
17396                                                   if (((word >> 13) & 0x1) == 0)
17397                                                     {
17398                                                       if (((word >> 14) & 0x1) == 0)
17399                                                         {
17400                                                           /* 33222222222211111111110000000000
17401                                                              10987654321098765432109876543210
17402                                                              0x001110xx1xxxxx000010xxxxxxxxxx
17403                                                              rev64.  */
17404                                                           return 162;
17405                                                         }
17406                                                       else
17407                                                         {
17408                                                           if (((word >> 16) & 0x1) == 0)
17409                                                             {
17410                                                               if (((word >> 19) & 0x1) == 0)
17411                                                                 {
17412                                                                   /* 33222222222211111111110000000000
17413                                                                      10987654321098765432109876543210
17414                                                                      0x001110xx1x0xx0010010xxxxxxxxxx
17415                                                                      cls.  */
17416                                                                   return 166;
17417                                                                 }
17418                                                               else
17419                                                                 {
17420                                                                   /* 33222222222211111111110000000000
17421                                                                      10987654321098765432109876543210
17422                                                                      0x001110xx1x1xx0010010xxxxxxxxxx
17423                                                                      aese.  */
17424                                                                   return 671;
17425                                                                 }
17426                                                             }
17427                                                           else
17428                                                             {
17429                                                               if (((word >> 30) & 0x1) == 0)
17430                                                                 {
17431                                                                   /* 33222222222211111111110000000000
17432                                                                      10987654321098765432109876543210
17433                                                                      00001110xx1xxxx1010010xxxxxxxxxx
17434                                                                      sqxtn.  */
17435                                                                   return 176;
17436                                                                 }
17437                                                               else
17438                                                                 {
17439                                                                   /* 33222222222211111111110000000000
17440                                                                      10987654321098765432109876543210
17441                                                                      01001110xx1xxxx1010010xxxxxxxxxx
17442                                                                      sqxtn2.  */
17443                                                                   return 177;
17444                                                                 }
17445                                                             }
17446                                                         }
17447                                                     }
17448                                                   else
17449                                                     {
17450                                                       if (((word >> 14) & 0x1) == 0)
17451                                                         {
17452                                                           if (((word >> 16) & 0x1) == 0)
17453                                                             {
17454                                                               /* 33222222222211111111110000000000
17455                                                                  10987654321098765432109876543210
17456                                                                  0x001110xx1xxxx0001010xxxxxxxxxx
17457                                                                  saddlp.  */
17458                                                               return 164;
17459                                                             }
17460                                                           else
17461                                                             {
17462                                                               if (((word >> 30) & 0x1) == 0)
17463                                                                 {
17464                                                                   /* 33222222222211111111110000000000
17465                                                                      10987654321098765432109876543210
17466                                                                      00001110xx1xxxx1001010xxxxxxxxxx
17467                                                                      xtn.  */
17468                                                                   return 174;
17469                                                                 }
17470                                                               else
17471                                                                 {
17472                                                                   /* 33222222222211111111110000000000
17473                                                                      10987654321098765432109876543210
17474                                                                      01001110xx1xxxx1001010xxxxxxxxxx
17475                                                                      xtn2.  */
17476                                                                   return 175;
17477                                                                 }
17478                                                             }
17479                                                         }
17480                                                       else
17481                                                         {
17482                                                           if (((word >> 16) & 0x1) == 0)
17483                                                             {
17484                                                               if (((word >> 19) & 0x1) == 0)
17485                                                                 {
17486                                                                   /* 33222222222211111111110000000000
17487                                                                      10987654321098765432109876543210
17488                                                                      0x001110xx1x0xx0011010xxxxxxxxxx
17489                                                                      sadalp.  */
17490                                                                   return 168;
17491                                                                 }
17492                                                               else
17493                                                                 {
17494                                                                   /* 33222222222211111111110000000000
17495                                                                      10987654321098765432109876543210
17496                                                                      0x001110xx1x1xx0011010xxxxxxxxxx
17497                                                                      aesmc.  */
17498                                                                   return 673;
17499                                                                 }
17500                                                             }
17501                                                           else
17502                                                             {
17503                                                               if (((word >> 23) & 0x1) == 0)
17504                                                                 {
17505                                                                   if (((word >> 30) & 0x1) == 0)
17506                                                                     {
17507                                                                       /* 33222222222211111111110000000000
17508                                                                          10987654321098765432109876543210
17509                                                                          000011100x1xxxx1011010xxxxxxxxxx
17510                                                                          fcvtn.  */
17511                                                                       return 178;
17512                                                                     }
17513                                                                   else
17514                                                                     {
17515                                                                       /* 33222222222211111111110000000000
17516                                                                          10987654321098765432109876543210
17517                                                                          010011100x1xxxx1011010xxxxxxxxxx
17518                                                                          fcvtn2.  */
17519                                                                       return 179;
17520                                                                     }
17521                                                                 }
17522                                                               else
17523                                                                 {
17524                                                                   if (((word >> 30) & 0x1) == 0)
17525                                                                     {
17526                                                                       /* 33222222222211111111110000000000
17527                                                                          10987654321098765432109876543210
17528                                                                          000011101x1xxxx1011010xxxxxxxxxx
17529                                                                          bfcvtn.  */
17530                                                                       return 2434;
17531                                                                     }
17532                                                                   else
17533                                                                     {
17534                                                                       /* 33222222222211111111110000000000
17535                                                                          10987654321098765432109876543210
17536                                                                          010011101x1xxxx1011010xxxxxxxxxx
17537                                                                          bfcvtn2.  */
17538                                                                       return 2435;
17539                                                                     }
17540                                                                 }
17541                                                             }
17542                                                         }
17543                                                     }
17544                                                 }
17545                                               else
17546                                                 {
17547                                                   if (((word >> 13) & 0x1) == 0)
17548                                                     {
17549                                                       if (((word >> 14) & 0x1) == 0)
17550                                                         {
17551                                                           /* 33222222222211111111110000000000
17552                                                              10987654321098765432109876543210
17553                                                              0x001110xx1xxxxx000110xxxxxxxxxx
17554                                                              rev16.  */
17555                                                           return 163;
17556                                                         }
17557                                                       else
17558                                                         {
17559                                                           if (((word >> 19) & 0x1) == 0)
17560                                                             {
17561                                                               /* 33222222222211111111110000000000
17562                                                                  10987654321098765432109876543210
17563                                                                  0x001110xx1x0xxx010110xxxxxxxxxx
17564                                                                  cnt.  */
17565                                                               return 167;
17566                                                             }
17567                                                           else
17568                                                             {
17569                                                               /* 33222222222211111111110000000000
17570                                                                  10987654321098765432109876543210
17571                                                                  0x001110xx1x1xxx010110xxxxxxxxxx
17572                                                                  aesd.  */
17573                                                               return 672;
17574                                                             }
17575                                                         }
17576                                                     }
17577                                                   else
17578                                                     {
17579                                                       if (((word >> 14) & 0x1) == 0)
17580                                                         {
17581                                                           if (((word >> 20) & 0x1) == 0)
17582                                                             {
17583                                                               /* 33222222222211111111110000000000
17584                                                                  10987654321098765432109876543210
17585                                                                  0x001110xx10xxxx001110xxxxxxxxxx
17586                                                                  suqadd.  */
17587                                                               return 165;
17588                                                             }
17589                                                           else
17590                                                             {
17591                                                               /* 33222222222211111111110000000000
17592                                                                  10987654321098765432109876543210
17593                                                                  0x001110xx11xxxx001110xxxxxxxxxx
17594                                                                  saddlv.  */
17595                                                               return 29;
17596                                                             }
17597                                                         }
17598                                                       else
17599                                                         {
17600                                                           if (((word >> 16) & 0x1) == 0)
17601                                                             {
17602                                                               if (((word >> 19) & 0x1) == 0)
17603                                                                 {
17604                                                                   /* 33222222222211111111110000000000
17605                                                                      10987654321098765432109876543210
17606                                                                      0x001110xx1x0xx0011110xxxxxxxxxx
17607                                                                      sqabs.  */
17608                                                                   return 169;
17609                                                                 }
17610                                                               else
17611                                                                 {
17612                                                                   /* 33222222222211111111110000000000
17613                                                                      10987654321098765432109876543210
17614                                                                      0x001110xx1x1xx0011110xxxxxxxxxx
17615                                                                      aesimc.  */
17616                                                                   return 674;
17617                                                                 }
17618                                                             }
17619                                                           else
17620                                                             {
17621                                                               if (((word >> 30) & 0x1) == 0)
17622                                                                 {
17623                                                                   /* 33222222222211111111110000000000
17624                                                                      10987654321098765432109876543210
17625                                                                      00001110xx1xxxx1011110xxxxxxxxxx
17626                                                                      fcvtl.  */
17627                                                                   return 180;
17628                                                                 }
17629                                                               else
17630                                                                 {
17631                                                                   /* 33222222222211111111110000000000
17632                                                                      10987654321098765432109876543210
17633                                                                      01001110xx1xxxx1011110xxxxxxxxxx
17634                                                                      fcvtl2.  */
17635                                                                   return 181;
17636                                                                 }
17637                                                             }
17638                                                         }
17639                                                     }
17640                                                 }
17641                                             }
17642                                         }
17643                                       else
17644                                         {
17645                                           if (((word >> 11) & 0x1) == 0)
17646                                             {
17647                                               if (((word >> 12) & 0x1) == 0)
17648                                                 {
17649                                                   if (((word >> 13) & 0x1) == 0)
17650                                                     {
17651                                                       if (((word >> 14) & 0x1) == 0)
17652                                                         {
17653                                                           /* 33222222222211111111110000000000
17654                                                              10987654321098765432109876543210
17655                                                              0x001110xx1xxxxx000001xxxxxxxxxx
17656                                                              shadd.  */
17657                                                           return 268;
17658                                                         }
17659                                                       else
17660                                                         {
17661                                                           /* 33222222222211111111110000000000
17662                                                              10987654321098765432109876543210
17663                                                              0x001110xx1xxxxx010001xxxxxxxxxx
17664                                                              sshl.  */
17665                                                           return 275;
17666                                                         }
17667                                                     }
17668                                                   else
17669                                                     {
17670                                                       if (((word >> 14) & 0x1) == 0)
17671                                                         {
17672                                                           /* 33222222222211111111110000000000
17673                                                              10987654321098765432109876543210
17674                                                              0x001110xx1xxxxx001001xxxxxxxxxx
17675                                                              shsub.  */
17676                                                           return 271;
17677                                                         }
17678                                                       else
17679                                                         {
17680                                                           /* 33222222222211111111110000000000
17681                                                              10987654321098765432109876543210
17682                                                              0x001110xx1xxxxx011001xxxxxxxxxx
17683                                                              smax.  */
17684                                                           return 279;
17685                                                         }
17686                                                     }
17687                                                 }
17688                                               else
17689                                                 {
17690                                                   if (((word >> 13) & 0x1) == 0)
17691                                                     {
17692                                                       if (((word >> 14) & 0x1) == 0)
17693                                                         {
17694                                                           /* 33222222222211111111110000000000
17695                                                              10987654321098765432109876543210
17696                                                              0x001110xx1xxxxx000101xxxxxxxxxx
17697                                                              srhadd.  */
17698                                                           return 270;
17699                                                         }
17700                                                       else
17701                                                         {
17702                                                           /* 33222222222211111111110000000000
17703                                                              10987654321098765432109876543210
17704                                                              0x001110xx1xxxxx010101xxxxxxxxxx
17705                                                              srshl.  */
17706                                                           return 277;
17707                                                         }
17708                                                     }
17709                                                   else
17710                                                     {
17711                                                       if (((word >> 14) & 0x1) == 0)
17712                                                         {
17713                                                           /* 33222222222211111111110000000000
17714                                                              10987654321098765432109876543210
17715                                                              0x001110xx1xxxxx001101xxxxxxxxxx
17716                                                              cmgt.  */
17717                                                           return 273;
17718                                                         }
17719                                                       else
17720                                                         {
17721                                                           /* 33222222222211111111110000000000
17722                                                              10987654321098765432109876543210
17723                                                              0x001110xx1xxxxx011101xxxxxxxxxx
17724                                                              sabd.  */
17725                                                           return 281;
17726                                                         }
17727                                                     }
17728                                                 }
17729                                             }
17730                                           else
17731                                             {
17732                                               if (((word >> 12) & 0x1) == 0)
17733                                                 {
17734                                                   if (((word >> 13) & 0x1) == 0)
17735                                                     {
17736                                                       if (((word >> 14) & 0x1) == 0)
17737                                                         {
17738                                                           /* 33222222222211111111110000000000
17739                                                              10987654321098765432109876543210
17740                                                              0x001110xx1xxxxx000011xxxxxxxxxx
17741                                                              sqadd.  */
17742                                                           return 269;
17743                                                         }
17744                                                       else
17745                                                         {
17746                                                           /* 33222222222211111111110000000000
17747                                                              10987654321098765432109876543210
17748                                                              0x001110xx1xxxxx010011xxxxxxxxxx
17749                                                              sqshl.  */
17750                                                           return 276;
17751                                                         }
17752                                                     }
17753                                                   else
17754                                                     {
17755                                                       if (((word >> 14) & 0x1) == 0)
17756                                                         {
17757                                                           /* 33222222222211111111110000000000
17758                                                              10987654321098765432109876543210
17759                                                              0x001110xx1xxxxx001011xxxxxxxxxx
17760                                                              sqsub.  */
17761                                                           return 272;
17762                                                         }
17763                                                       else
17764                                                         {
17765                                                           /* 33222222222211111111110000000000
17766                                                              10987654321098765432109876543210
17767                                                              0x001110xx1xxxxx011011xxxxxxxxxx
17768                                                              smin.  */
17769                                                           return 280;
17770                                                         }
17771                                                     }
17772                                                 }
17773                                               else
17774                                                 {
17775                                                   if (((word >> 13) & 0x1) == 0)
17776                                                     {
17777                                                       if (((word >> 14) & 0x1) == 0)
17778                                                         {
17779                                                           if (((word >> 22) & 0x1) == 0)
17780                                                             {
17781                                                               if (((word >> 23) & 0x1) == 0)
17782                                                                 {
17783                                                                   /* 33222222222211111111110000000000
17784                                                                      10987654321098765432109876543210
17785                                                                      0x001110001xxxxx000111xxxxxxxxxx
17786                                                                      and.  */
17787                                                                   return 305;
17788                                                                 }
17789                                                               else
17790                                                                 {
17791                                                                   /* 33222222222211111111110000000000
17792                                                                      10987654321098765432109876543210
17793                                                                      0x001110101xxxxx000111xxxxxxxxxx
17794                                                                      orr.  */
17795                                                                   return 317;
17796                                                                 }
17797                                                             }
17798                                                           else
17799                                                             {
17800                                                               if (((word >> 23) & 0x1) == 0)
17801                                                                 {
17802                                                                   /* 33222222222211111111110000000000
17803                                                                      10987654321098765432109876543210
17804                                                                      0x001110011xxxxx000111xxxxxxxxxx
17805                                                                      bic.  */
17806                                                                   return 306;
17807                                                                 }
17808                                                               else
17809                                                                 {
17810                                                                   /* 33222222222211111111110000000000
17811                                                                      10987654321098765432109876543210
17812                                                                      0x001110111xxxxx000111xxxxxxxxxx
17813                                                                      orn.  */
17814                                                                   return 319;
17815                                                                 }
17816                                                             }
17817                                                         }
17818                                                       else
17819                                                         {
17820                                                           /* 33222222222211111111110000000000
17821                                                              10987654321098765432109876543210
17822                                                              0x001110xx1xxxxx010111xxxxxxxxxx
17823                                                              sqrshl.  */
17824                                                           return 278;
17825                                                         }
17826                                                     }
17827                                                   else
17828                                                     {
17829                                                       if (((word >> 14) & 0x1) == 0)
17830                                                         {
17831                                                           /* 33222222222211111111110000000000
17832                                                              10987654321098765432109876543210
17833                                                              0x001110xx1xxxxx001111xxxxxxxxxx
17834                                                              cmge.  */
17835                                                           return 274;
17836                                                         }
17837                                                       else
17838                                                         {
17839                                                           /* 33222222222211111111110000000000
17840                                                              10987654321098765432109876543210
17841                                                              0x001110xx1xxxxx011111xxxxxxxxxx
17842                                                              saba.  */
17843                                                           return 282;
17844                                                         }
17845                                                     }
17846                                                 }
17847                                             }
17848                                         }
17849                                     }
17850                                   else
17851                                     {
17852                                       /* 33222222222211111111110000000000
17853                                          10987654321098765432109876543210
17854                                          1x001110xx1xxxxx0xxxxxxxxxxxxxxx
17855                                          bcax.  */
17856                                       return 2352;
17857                                     }
17858                                 }
17859                               else
17860                                 {
17861                                   if (((word >> 10) & 0x1) == 0)
17862                                     {
17863                                       if (((word >> 11) & 0x1) == 0)
17864                                         {
17865                                           if (((word >> 12) & 0x1) == 0)
17866                                             {
17867                                               if (((word >> 13) & 0x1) == 0)
17868                                                 {
17869                                                   if (((word >> 14) & 0x1) == 0)
17870                                                     {
17871                                                       if (((word >> 30) & 0x1) == 0)
17872                                                         {
17873                                                           /* 33222222222211111111110000000000
17874                                                              10987654321098765432109876543210
17875                                                              x0101110xx1xxxxx000000xxxxxxxxxx
17876                                                              uaddl.  */
17877                                                           return 76;
17878                                                         }
17879                                                       else
17880                                                         {
17881                                                           /* 33222222222211111111110000000000
17882                                                              10987654321098765432109876543210
17883                                                              x1101110xx1xxxxx000000xxxxxxxxxx
17884                                                              uaddl2.  */
17885                                                           return 77;
17886                                                         }
17887                                                     }
17888                                                   else
17889                                                     {
17890                                                       if (((word >> 30) & 0x1) == 0)
17891                                                         {
17892                                                           /* 33222222222211111111110000000000
17893                                                              10987654321098765432109876543210
17894                                                              x0101110xx1xxxxx010000xxxxxxxxxx
17895                                                              raddhn.  */
17896                                                           return 84;
17897                                                         }
17898                                                       else
17899                                                         {
17900                                                           /* 33222222222211111111110000000000
17901                                                              10987654321098765432109876543210
17902                                                              x1101110xx1xxxxx010000xxxxxxxxxx
17903                                                              raddhn2.  */
17904                                                           return 85;
17905                                                         }
17906                                                     }
17907                                                 }
17908                                               else
17909                                                 {
17910                                                   if (((word >> 14) & 0x1) == 0)
17911                                                     {
17912                                                       if (((word >> 30) & 0x1) == 0)
17913                                                         {
17914                                                           /* 33222222222211111111110000000000
17915                                                              10987654321098765432109876543210
17916                                                              x0101110xx1xxxxx001000xxxxxxxxxx
17917                                                              usubl.  */
17918                                                           return 80;
17919                                                         }
17920                                                       else
17921                                                         {
17922                                                           /* 33222222222211111111110000000000
17923                                                              10987654321098765432109876543210
17924                                                              x1101110xx1xxxxx001000xxxxxxxxxx
17925                                                              usubl2.  */
17926                                                           return 81;
17927                                                         }
17928                                                     }
17929                                                   else
17930                                                     {
17931                                                       if (((word >> 30) & 0x1) == 0)
17932                                                         {
17933                                                           /* 33222222222211111111110000000000
17934                                                              10987654321098765432109876543210
17935                                                              x0101110xx1xxxxx011000xxxxxxxxxx
17936                                                              rsubhn.  */
17937                                                           return 88;
17938                                                         }
17939                                                       else
17940                                                         {
17941                                                           /* 33222222222211111111110000000000
17942                                                              10987654321098765432109876543210
17943                                                              x1101110xx1xxxxx011000xxxxxxxxxx
17944                                                              rsubhn2.  */
17945                                                           return 89;
17946                                                         }
17947                                                     }
17948                                                 }
17949                                             }
17950                                           else
17951                                             {
17952                                               if (((word >> 13) & 0x1) == 0)
17953                                                 {
17954                                                   if (((word >> 14) & 0x1) == 0)
17955                                                     {
17956                                                       if (((word >> 30) & 0x1) == 0)
17957                                                         {
17958                                                           /* 33222222222211111111110000000000
17959                                                              10987654321098765432109876543210
17960                                                              x0101110xx1xxxxx000100xxxxxxxxxx
17961                                                              uaddw.  */
17962                                                           return 78;
17963                                                         }
17964                                                       else
17965                                                         {
17966                                                           /* 33222222222211111111110000000000
17967                                                              10987654321098765432109876543210
17968                                                              x1101110xx1xxxxx000100xxxxxxxxxx
17969                                                              uaddw2.  */
17970                                                           return 79;
17971                                                         }
17972                                                     }
17973                                                   else
17974                                                     {
17975                                                       if (((word >> 30) & 0x1) == 0)
17976                                                         {
17977                                                           /* 33222222222211111111110000000000
17978                                                              10987654321098765432109876543210
17979                                                              x0101110xx1xxxxx010100xxxxxxxxxx
17980                                                              uabal.  */
17981                                                           return 86;
17982                                                         }
17983                                                       else
17984                                                         {
17985                                                           /* 33222222222211111111110000000000
17986                                                              10987654321098765432109876543210
17987                                                              x1101110xx1xxxxx010100xxxxxxxxxx
17988                                                              uabal2.  */
17989                                                           return 87;
17990                                                         }
17991                                                     }
17992                                                 }
17993                                               else
17994                                                 {
17995                                                   if (((word >> 14) & 0x1) == 0)
17996                                                     {
17997                                                       if (((word >> 30) & 0x1) == 0)
17998                                                         {
17999                                                           /* 33222222222211111111110000000000
18000                                                              10987654321098765432109876543210
18001                                                              x0101110xx1xxxxx001100xxxxxxxxxx
18002                                                              usubw.  */
18003                                                           return 82;
18004                                                         }
18005                                                       else
18006                                                         {
18007                                                           /* 33222222222211111111110000000000
18008                                                              10987654321098765432109876543210
18009                                                              x1101110xx1xxxxx001100xxxxxxxxxx
18010                                                              usubw2.  */
18011                                                           return 83;
18012                                                         }
18013                                                     }
18014                                                   else
18015                                                     {
18016                                                       if (((word >> 30) & 0x1) == 0)
18017                                                         {
18018                                                           /* 33222222222211111111110000000000
18019                                                              10987654321098765432109876543210
18020                                                              x0101110xx1xxxxx011100xxxxxxxxxx
18021                                                              uabdl.  */
18022                                                           return 90;
18023                                                         }
18024                                                       else
18025                                                         {
18026                                                           /* 33222222222211111111110000000000
18027                                                              10987654321098765432109876543210
18028                                                              x1101110xx1xxxxx011100xxxxxxxxxx
18029                                                              uabdl2.  */
18030                                                           return 91;
18031                                                         }
18032                                                     }
18033                                                 }
18034                                             }
18035                                         }
18036                                       else
18037                                         {
18038                                           if (((word >> 12) & 0x1) == 0)
18039                                             {
18040                                               if (((word >> 13) & 0x1) == 0)
18041                                                 {
18042                                                   if (((word >> 14) & 0x1) == 0)
18043                                                     {
18044                                                       /* 33222222222211111111110000000000
18045                                                          10987654321098765432109876543210
18046                                                          xx101110xx1xxxxx000010xxxxxxxxxx
18047                                                          rev32.  */
18048                                                       return 213;
18049                                                     }
18050                                                   else
18051                                                     {
18052                                                       if (((word >> 16) & 0x1) == 0)
18053                                                         {
18054                                                           /* 33222222222211111111110000000000
18055                                                              10987654321098765432109876543210
18056                                                              xx101110xx1xxxx0010010xxxxxxxxxx
18057                                                              clz.  */
18058                                                           return 216;
18059                                                         }
18060                                                       else
18061                                                         {
18062                                                           if (((word >> 30) & 0x1) == 0)
18063                                                             {
18064                                                               /* 33222222222211111111110000000000
18065                                                                  10987654321098765432109876543210
18066                                                                  x0101110xx1xxxx1010010xxxxxxxxxx
18067                                                                  uqxtn.  */
18068                                                               return 226;
18069                                                             }
18070                                                           else
18071                                                             {
18072                                                               /* 33222222222211111111110000000000
18073                                                                  10987654321098765432109876543210
18074                                                                  x1101110xx1xxxx1010010xxxxxxxxxx
18075                                                                  uqxtn2.  */
18076                                                               return 227;
18077                                                             }
18078                                                         }
18079                                                     }
18080                                                 }
18081                                               else
18082                                                 {
18083                                                   if (((word >> 14) & 0x1) == 0)
18084                                                     {
18085                                                       if (((word >> 16) & 0x1) == 0)
18086                                                         {
18087                                                           /* 33222222222211111111110000000000
18088                                                              10987654321098765432109876543210
18089                                                              xx101110xx1xxxx0001010xxxxxxxxxx
18090                                                              uaddlp.  */
18091                                                           return 214;
18092                                                         }
18093                                                       else
18094                                                         {
18095                                                           if (((word >> 30) & 0x1) == 0)
18096                                                             {
18097                                                               /* 33222222222211111111110000000000
18098                                                                  10987654321098765432109876543210
18099                                                                  x0101110xx1xxxx1001010xxxxxxxxxx
18100                                                                  sqxtun.  */
18101                                                               return 222;
18102                                                             }
18103                                                           else
18104                                                             {
18105                                                               /* 33222222222211111111110000000000
18106                                                                  10987654321098765432109876543210
18107                                                                  x1101110xx1xxxx1001010xxxxxxxxxx
18108                                                                  sqxtun2.  */
18109                                                               return 223;
18110                                                             }
18111                                                         }
18112                                                     }
18113                                                   else
18114                                                     {
18115                                                       if (((word >> 16) & 0x1) == 0)
18116                                                         {
18117                                                           /* 33222222222211111111110000000000
18118                                                              10987654321098765432109876543210
18119                                                              xx101110xx1xxxx0011010xxxxxxxxxx
18120                                                              uadalp.  */
18121                                                           return 217;
18122                                                         }
18123                                                       else
18124                                                         {
18125                                                           if (((word >> 30) & 0x1) == 0)
18126                                                             {
18127                                                               /* 33222222222211111111110000000000
18128                                                                  10987654321098765432109876543210
18129                                                                  x0101110xx1xxxx1011010xxxxxxxxxx
18130                                                                  fcvtxn.  */
18131                                                               return 228;
18132                                                             }
18133                                                           else
18134                                                             {
18135                                                               /* 33222222222211111111110000000000
18136                                                                  10987654321098765432109876543210
18137                                                                  x1101110xx1xxxx1011010xxxxxxxxxx
18138                                                                  fcvtxn2.  */
18139                                                               return 229;
18140                                                             }
18141                                                         }
18142                                                     }
18143                                                 }
18144                                             }
18145                                           else
18146                                             {
18147                                               if (((word >> 13) & 0x1) == 0)
18148                                                 {
18149                                                   if (((word >> 22) & 0x1) == 0)
18150                                                     {
18151                                                       /* 33222222222211111111110000000000
18152                                                          10987654321098765432109876543210
18153                                                          xx101110x01xxxxx0x0110xxxxxxxxxx
18154                                                          not.  */
18155                                                       return 242;
18156                                                     }
18157                                                   else
18158                                                     {
18159                                                       /* 33222222222211111111110000000000
18160                                                          10987654321098765432109876543210
18161                                                          xx101110x11xxxxx0x0110xxxxxxxxxx
18162                                                          rbit.  */
18163                                                       return 244;
18164                                                     }
18165                                                 }
18166                                               else
18167                                                 {
18168                                                   if (((word >> 14) & 0x1) == 0)
18169                                                     {
18170                                                       if (((word >> 16) & 0x1) == 0)
18171                                                         {
18172                                                           if (((word >> 20) & 0x1) == 0)
18173                                                             {
18174                                                               /* 33222222222211111111110000000000
18175                                                                  10987654321098765432109876543210
18176                                                                  xx101110xx10xxx0001110xxxxxxxxxx
18177                                                                  usqadd.  */
18178                                                               return 215;
18179                                                             }
18180                                                           else
18181                                                             {
18182                                                               /* 33222222222211111111110000000000
18183                                                                  10987654321098765432109876543210
18184                                                                  xx101110xx11xxx0001110xxxxxxxxxx
18185                                                                  uaddlv.  */
18186                                                               return 33;
18187                                                             }
18188                                                         }
18189                                                       else
18190                                                         {
18191                                                           if (((word >> 30) & 0x1) == 0)
18192                                                             {
18193                                                               /* 33222222222211111111110000000000
18194                                                                  10987654321098765432109876543210
18195                                                                  x0101110xx1xxxx1001110xxxxxxxxxx
18196                                                                  shll.  */
18197                                                               return 224;
18198                                                             }
18199                                                           else
18200                                                             {
18201                                                               /* 33222222222211111111110000000000
18202                                                                  10987654321098765432109876543210
18203                                                                  x1101110xx1xxxx1001110xxxxxxxxxx
18204                                                                  shll2.  */
18205                                                               return 225;
18206                                                             }
18207                                                         }
18208                                                     }
18209                                                   else
18210                                                     {
18211                                                       /* 33222222222211111111110000000000
18212                                                          10987654321098765432109876543210
18213                                                          xx101110xx1xxxxx011110xxxxxxxxxx
18214                                                          sqneg.  */
18215                                                       return 218;
18216                                                     }
18217                                                 }
18218                                             }
18219                                         }
18220                                     }
18221                                   else
18222                                     {
18223                                       if (((word >> 11) & 0x1) == 0)
18224                                         {
18225                                           if (((word >> 12) & 0x1) == 0)
18226                                             {
18227                                               if (((word >> 13) & 0x1) == 0)
18228                                                 {
18229                                                   if (((word >> 14) & 0x1) == 0)
18230                                                     {
18231                                                       /* 33222222222211111111110000000000
18232                                                          10987654321098765432109876543210
18233                                                          xx101110xx1xxxxx000001xxxxxxxxxx
18234                                                          uhadd.  */
18235                                                       return 320;
18236                                                     }
18237                                                   else
18238                                                     {
18239                                                       /* 33222222222211111111110000000000
18240                                                          10987654321098765432109876543210
18241                                                          xx101110xx1xxxxx010001xxxxxxxxxx
18242                                                          ushl.  */
18243                                                       return 327;
18244                                                     }
18245                                                 }
18246                                               else
18247                                                 {
18248                                                   if (((word >> 14) & 0x1) == 0)
18249                                                     {
18250                                                       /* 33222222222211111111110000000000
18251                                                          10987654321098765432109876543210
18252                                                          xx101110xx1xxxxx001001xxxxxxxxxx
18253                                                          uhsub.  */
18254                                                       return 323;
18255                                                     }
18256                                                   else
18257                                                     {
18258                                                       /* 33222222222211111111110000000000
18259                                                          10987654321098765432109876543210
18260                                                          xx101110xx1xxxxx011001xxxxxxxxxx
18261                                                          umax.  */
18262                                                       return 331;
18263                                                     }
18264                                                 }
18265                                             }
18266                                           else
18267                                             {
18268                                               if (((word >> 13) & 0x1) == 0)
18269                                                 {
18270                                                   if (((word >> 14) & 0x1) == 0)
18271                                                     {
18272                                                       /* 33222222222211111111110000000000
18273                                                          10987654321098765432109876543210
18274                                                          xx101110xx1xxxxx000101xxxxxxxxxx
18275                                                          urhadd.  */
18276                                                       return 322;
18277                                                     }
18278                                                   else
18279                                                     {
18280                                                       /* 33222222222211111111110000000000
18281                                                          10987654321098765432109876543210
18282                                                          xx101110xx1xxxxx010101xxxxxxxxxx
18283                                                          urshl.  */
18284                                                       return 329;
18285                                                     }
18286                                                 }
18287                                               else
18288                                                 {
18289                                                   if (((word >> 14) & 0x1) == 0)
18290                                                     {
18291                                                       /* 33222222222211111111110000000000
18292                                                          10987654321098765432109876543210
18293                                                          xx101110xx1xxxxx001101xxxxxxxxxx
18294                                                          cmhi.  */
18295                                                       return 325;
18296                                                     }
18297                                                   else
18298                                                     {
18299                                                       /* 33222222222211111111110000000000
18300                                                          10987654321098765432109876543210
18301                                                          xx101110xx1xxxxx011101xxxxxxxxxx
18302                                                          uabd.  */
18303                                                       return 333;
18304                                                     }
18305                                                 }
18306                                             }
18307                                         }
18308                                       else
18309                                         {
18310                                           if (((word >> 12) & 0x1) == 0)
18311                                             {
18312                                               if (((word >> 13) & 0x1) == 0)
18313                                                 {
18314                                                   if (((word >> 14) & 0x1) == 0)
18315                                                     {
18316                                                       /* 33222222222211111111110000000000
18317                                                          10987654321098765432109876543210
18318                                                          xx101110xx1xxxxx000011xxxxxxxxxx
18319                                                          uqadd.  */
18320                                                       return 321;
18321                                                     }
18322                                                   else
18323                                                     {
18324                                                       /* 33222222222211111111110000000000
18325                                                          10987654321098765432109876543210
18326                                                          xx101110xx1xxxxx010011xxxxxxxxxx
18327                                                          uqshl.  */
18328                                                       return 328;
18329                                                     }
18330                                                 }
18331                                               else
18332                                                 {
18333                                                   if (((word >> 14) & 0x1) == 0)
18334                                                     {
18335                                                       /* 33222222222211111111110000000000
18336                                                          10987654321098765432109876543210
18337                                                          xx101110xx1xxxxx001011xxxxxxxxxx
18338                                                          uqsub.  */
18339                                                       return 324;
18340                                                     }
18341                                                   else
18342                                                     {
18343                                                       /* 33222222222211111111110000000000
18344                                                          10987654321098765432109876543210
18345                                                          xx101110xx1xxxxx011011xxxxxxxxxx
18346                                                          umin.  */
18347                                                       return 332;
18348                                                     }
18349                                                 }
18350                                             }
18351                                           else
18352                                             {
18353                                               if (((word >> 13) & 0x1) == 0)
18354                                                 {
18355                                                   if (((word >> 14) & 0x1) == 0)
18356                                                     {
18357                                                       if (((word >> 22) & 0x1) == 0)
18358                                                         {
18359                                                           if (((word >> 23) & 0x1) == 0)
18360                                                             {
18361                                                               /* 33222222222211111111110000000000
18362                                                                  10987654321098765432109876543210
18363                                                                  xx101110001xxxxx000111xxxxxxxxxx
18364                                                                  eor.  */
18365                                                               return 356;
18366                                                             }
18367                                                           else
18368                                                             {
18369                                                               /* 33222222222211111111110000000000
18370                                                                  10987654321098765432109876543210
18371                                                                  xx101110101xxxxx000111xxxxxxxxxx
18372                                                                  bit.  */
18373                                                               return 368;
18374                                                             }
18375                                                         }
18376                                                       else
18377                                                         {
18378                                                           if (((word >> 23) & 0x1) == 0)
18379                                                             {
18380                                                               /* 33222222222211111111110000000000
18381                                                                  10987654321098765432109876543210
18382                                                                  xx101110011xxxxx000111xxxxxxxxxx
18383                                                                  bsl.  */
18384                                                               return 357;
18385                                                             }
18386                                                           else
18387                                                             {
18388                                                               /* 33222222222211111111110000000000
18389                                                                  10987654321098765432109876543210
18390                                                                  xx101110111xxxxx000111xxxxxxxxxx
18391                                                                  bif.  */
18392                                                               return 369;
18393                                                             }
18394                                                         }
18395                                                     }
18396                                                   else
18397                                                     {
18398                                                       /* 33222222222211111111110000000000
18399                                                          10987654321098765432109876543210
18400                                                          xx101110xx1xxxxx010111xxxxxxxxxx
18401                                                          uqrshl.  */
18402                                                       return 330;
18403                                                     }
18404                                                 }
18405                                               else
18406                                                 {
18407                                                   if (((word >> 14) & 0x1) == 0)
18408                                                     {
18409                                                       /* 33222222222211111111110000000000
18410                                                          10987654321098765432109876543210
18411                                                          xx101110xx1xxxxx001111xxxxxxxxxx
18412                                                          cmhs.  */
18413                                                       return 326;
18414                                                     }
18415                                                   else
18416                                                     {
18417                                                       /* 33222222222211111111110000000000
18418                                                          10987654321098765432109876543210
18419                                                          xx101110xx1xxxxx011111xxxxxxxxxx
18420                                                          uaba.  */
18421                                                       return 334;
18422                                                     }
18423                                                 }
18424                                             }
18425                                         }
18426                                     }
18427                                 }
18428                             }
18429                           else
18430                             {
18431                               if (((word >> 10) & 0x1) == 0)
18432                                 {
18433                                   if (((word >> 11) & 0x1) == 0)
18434                                     {
18435                                       if (((word >> 12) & 0x1) == 0)
18436                                         {
18437                                           if (((word >> 13) & 0x1) == 0)
18438                                             {
18439                                               if (((word >> 14) & 0x1) == 0)
18440                                                 {
18441                                                   if (((word >> 29) & 0x1) == 0)
18442                                                     {
18443                                                       if (((word >> 30) & 0x1) == 0)
18444                                                         {
18445                                                           /* 33222222222211111111110000000000
18446                                                              10987654321098765432109876543210
18447                                                              x0001110xx1xxxxx100000xxxxxxxxxx
18448                                                              smlal.  */
18449                                                           return 60;
18450                                                         }
18451                                                       else
18452                                                         {
18453                                                           if (((word >> 31) & 0x1) == 0)
18454                                                             {
18455                                                               /* 33222222222211111111110000000000
18456                                                                  10987654321098765432109876543210
18457                                                                  01001110xx1xxxxx100000xxxxxxxxxx
18458                                                                  smlal2.  */
18459                                                               return 61;
18460                                                             }
18461                                                           else
18462                                                             {
18463                                                               /* 33222222222211111111110000000000
18464                                                                  10987654321098765432109876543210
18465                                                                  11001110xx1xxxxx100000xxxxxxxxxx
18466                                                                  sha512h.  */
18467                                                               return 2345;
18468                                                             }
18469                                                         }
18470                                                     }
18471                                                   else
18472                                                     {
18473                                                       if (((word >> 30) & 0x1) == 0)
18474                                                         {
18475                                                           /* 33222222222211111111110000000000
18476                                                              10987654321098765432109876543210
18477                                                              x0101110xx1xxxxx100000xxxxxxxxxx
18478                                                              umlal.  */
18479                                                           return 92;
18480                                                         }
18481                                                       else
18482                                                         {
18483                                                           /* 33222222222211111111110000000000
18484                                                              10987654321098765432109876543210
18485                                                              x1101110xx1xxxxx100000xxxxxxxxxx
18486                                                              umlal2.  */
18487                                                           return 93;
18488                                                         }
18489                                                     }
18490                                                 }
18491                                               else
18492                                                 {
18493                                                   if (((word >> 29) & 0x1) == 0)
18494                                                     {
18495                                                       if (((word >> 30) & 0x1) == 0)
18496                                                         {
18497                                                           /* 33222222222211111111110000000000
18498                                                              10987654321098765432109876543210
18499                                                              x0001110xx1xxxxx110000xxxxxxxxxx
18500                                                              smull.  */
18501                                                           return 68;
18502                                                         }
18503                                                       else
18504                                                         {
18505                                                           if (((word >> 31) & 0x1) == 0)
18506                                                             {
18507                                                               /* 33222222222211111111110000000000
18508                                                                  10987654321098765432109876543210
18509                                                                  01001110xx1xxxxx110000xxxxxxxxxx
18510                                                                  smull2.  */
18511                                                               return 69;
18512                                                             }
18513                                                           else
18514                                                             {
18515                                                               /* 33222222222211111111110000000000
18516                                                                  10987654321098765432109876543210
18517                                                                  11001110xx1xxxxx110000xxxxxxxxxx
18518                                                                  sm3partw1.  */
18519                                                               return 2358;
18520                                                             }
18521                                                         }
18522                                                     }
18523                                                   else
18524                                                     {
18525                                                       if (((word >> 30) & 0x1) == 0)
18526                                                         {
18527                                                           /* 33222222222211111111110000000000
18528                                                              10987654321098765432109876543210
18529                                                              x0101110xx1xxxxx110000xxxxxxxxxx
18530                                                              umull.  */
18531                                                           return 96;
18532                                                         }
18533                                                       else
18534                                                         {
18535                                                           /* 33222222222211111111110000000000
18536                                                              10987654321098765432109876543210
18537                                                              x1101110xx1xxxxx110000xxxxxxxxxx
18538                                                              umull2.  */
18539                                                           return 97;
18540                                                         }
18541                                                     }
18542                                                 }
18543                                             }
18544                                           else
18545                                             {
18546                                               if (((word >> 14) & 0x1) == 0)
18547                                                 {
18548                                                   if (((word >> 29) & 0x1) == 0)
18549                                                     {
18550                                                       if (((word >> 30) & 0x1) == 0)
18551                                                         {
18552                                                           /* 33222222222211111111110000000000
18553                                                              10987654321098765432109876543210
18554                                                              x0001110xx1xxxxx101000xxxxxxxxxx
18555                                                              smlsl.  */
18556                                                           return 64;
18557                                                         }
18558                                                       else
18559                                                         {
18560                                                           /* 33222222222211111111110000000000
18561                                                              10987654321098765432109876543210
18562                                                              x1001110xx1xxxxx101000xxxxxxxxxx
18563                                                              smlsl2.  */
18564                                                           return 65;
18565                                                         }
18566                                                     }
18567                                                   else
18568                                                     {
18569                                                       if (((word >> 30) & 0x1) == 0)
18570                                                         {
18571                                                           /* 33222222222211111111110000000000
18572                                                              10987654321098765432109876543210
18573                                                              x0101110xx1xxxxx101000xxxxxxxxxx
18574                                                              umlsl.  */
18575                                                           return 94;
18576                                                         }
18577                                                       else
18578                                                         {
18579                                                           /* 33222222222211111111110000000000
18580                                                              10987654321098765432109876543210
18581                                                              x1101110xx1xxxxx101000xxxxxxxxxx
18582                                                              umlsl2.  */
18583                                                           return 95;
18584                                                         }
18585                                                     }
18586                                                 }
18587                                               else
18588                                                 {
18589                                                   if (((word >> 22) & 0x1) == 0)
18590                                                     {
18591                                                       if (((word >> 30) & 0x1) == 0)
18592                                                         {
18593                                                           /* 33222222222211111111110000000000
18594                                                              10987654321098765432109876543210
18595                                                              x0x01110x01xxxxx111000xxxxxxxxxx
18596                                                              pmull.  */
18597                                                           return 72;
18598                                                         }
18599                                                       else
18600                                                         {
18601                                                           /* 33222222222211111111110000000000
18602                                                              10987654321098765432109876543210
18603                                                              x1x01110x01xxxxx111000xxxxxxxxxx
18604                                                              pmull2.  */
18605                                                           return 74;
18606                                                         }
18607                                                     }
18608                                                   else
18609                                                     {
18610                                                       if (((word >> 30) & 0x1) == 0)
18611                                                         {
18612                                                           /* 33222222222211111111110000000000
18613                                                              10987654321098765432109876543210
18614                                                              x0x01110x11xxxxx111000xxxxxxxxxx
18615                                                              pmull.  */
18616                                                           return 73;
18617                                                         }
18618                                                       else
18619                                                         {
18620                                                           /* 33222222222211111111110000000000
18621                                                              10987654321098765432109876543210
18622                                                              x1x01110x11xxxxx111000xxxxxxxxxx
18623                                                              pmull2.  */
18624                                                           return 75;
18625                                                         }
18626                                                     }
18627                                                 }
18628                                             }
18629                                         }
18630                                       else
18631                                         {
18632                                           if (((word >> 13) & 0x1) == 0)
18633                                             {
18634                                               if (((word >> 14) & 0x1) == 0)
18635                                                 {
18636                                                   if (((word >> 30) & 0x1) == 0)
18637                                                     {
18638                                                       /* 33222222222211111111110000000000
18639                                                          10987654321098765432109876543210
18640                                                          x0x01110xx1xxxxx100100xxxxxxxxxx
18641                                                          sqdmlal.  */
18642                                                       return 62;
18643                                                     }
18644                                                   else
18645                                                     {
18646                                                       /* 33222222222211111111110000000000
18647                                                          10987654321098765432109876543210
18648                                                          x1x01110xx1xxxxx100100xxxxxxxxxx
18649                                                          sqdmlal2.  */
18650                                                       return 63;
18651                                                     }
18652                                                 }
18653                                               else
18654                                                 {
18655                                                   if (((word >> 30) & 0x1) == 0)
18656                                                     {
18657                                                       /* 33222222222211111111110000000000
18658                                                          10987654321098765432109876543210
18659                                                          x0x01110xx1xxxxx110100xxxxxxxxxx
18660                                                          sqdmull.  */
18661                                                       return 70;
18662                                                     }
18663                                                   else
18664                                                     {
18665                                                       /* 33222222222211111111110000000000
18666                                                          10987654321098765432109876543210
18667                                                          x1x01110xx1xxxxx110100xxxxxxxxxx
18668                                                          sqdmull2.  */
18669                                                       return 71;
18670                                                     }
18671                                                 }
18672                                             }
18673                                           else
18674                                             {
18675                                               if (((word >> 30) & 0x1) == 0)
18676                                                 {
18677                                                   /* 33222222222211111111110000000000
18678                                                      10987654321098765432109876543210
18679                                                      x0x01110xx1xxxxx1x1100xxxxxxxxxx
18680                                                      sqdmlsl.  */
18681                                                   return 66;
18682                                                 }
18683                                               else
18684                                                 {
18685                                                   /* 33222222222211111111110000000000
18686                                                      10987654321098765432109876543210
18687                                                      x1x01110xx1xxxxx1x1100xxxxxxxxxx
18688                                                      sqdmlsl2.  */
18689                                                   return 67;
18690                                                 }
18691                                             }
18692                                         }
18693                                     }
18694                                   else
18695                                     {
18696                                       if (((word >> 12) & 0x1) == 0)
18697                                         {
18698                                           if (((word >> 13) & 0x1) == 0)
18699                                             {
18700                                               if (((word >> 14) & 0x1) == 0)
18701                                                 {
18702                                                   if (((word >> 29) & 0x1) == 0)
18703                                                     {
18704                                                       if (((word >> 31) & 0x1) == 0)
18705                                                         {
18706                                                           if (((word >> 16) & 0x1) == 0)
18707                                                             {
18708                                                               /* 33222222222211111111110000000000
18709                                                                  10987654321098765432109876543210
18710                                                                  0x001110xx1xxxx0100010xxxxxxxxxx
18711                                                                  cmgt.  */
18712                                                               return 170;
18713                                                             }
18714                                                           else
18715                                                             {
18716                                                               if (((word >> 19) & 0x1) == 0)
18717                                                                 {
18718                                                                   if (((word >> 23) & 0x1) == 0)
18719                                                                     {
18720                                                                       /* 33222222222211111111110000000000
18721                                                                          10987654321098765432109876543210
18722                                                                          0x0011100x1x0xx1100010xxxxxxxxxx
18723                                                                          frintn.  */
18724                                                                       return 182;
18725                                                                     }
18726                                                                   else
18727                                                                     {
18728                                                                       /* 33222222222211111111110000000000
18729                                                                          10987654321098765432109876543210
18730                                                                          0x0011101x1x0xx1100010xxxxxxxxxx
18731                                                                          frintp.  */
18732                                                                       return 202;
18733                                                                     }
18734                                                                 }
18735                                                               else
18736                                                                 {
18737                                                                   if (((word >> 23) & 0x1) == 0)
18738                                                                     {
18739                                                                       /* 33222222222211111111110000000000
18740                                                                          10987654321098765432109876543210
18741                                                                          0x0011100x1x1xx1100010xxxxxxxxxx
18742                                                                          frintn.  */
18743                                                                       return 183;
18744                                                                     }
18745                                                                   else
18746                                                                     {
18747                                                                       /* 33222222222211111111110000000000
18748                                                                          10987654321098765432109876543210
18749                                                                          0x0011101x1x1xx1100010xxxxxxxxxx
18750                                                                          frintp.  */
18751                                                                       return 203;
18752                                                                     }
18753                                                                 }
18754                                                             }
18755                                                         }
18756                                                       else
18757                                                         {
18758                                                           /* 33222222222211111111110000000000
18759                                                              10987654321098765432109876543210
18760                                                              1x001110xx1xxxxx100010xxxxxxxxxx
18761                                                              sha512su1.  */
18762                                                           return 2348;
18763                                                         }
18764                                                     }
18765                                                   else
18766                                                     {
18767                                                       if (((word >> 16) & 0x1) == 0)
18768                                                         {
18769                                                           /* 33222222222211111111110000000000
18770                                                              10987654321098765432109876543210
18771                                                              xx101110xx1xxxx0100010xxxxxxxxxx
18772                                                              cmge.  */
18773                                                           return 219;
18774                                                         }
18775                                                       else
18776                                                         {
18777                                                           if (((word >> 19) & 0x1) == 0)
18778                                                             {
18779                                                               /* 33222222222211111111110000000000
18780                                                                  10987654321098765432109876543210
18781                                                                  xx101110xx1x0xx1100010xxxxxxxxxx
18782                                                                  frinta.  */
18783                                                               return 230;
18784                                                             }
18785                                                           else
18786                                                             {
18787                                                               /* 33222222222211111111110000000000
18788                                                                  10987654321098765432109876543210
18789                                                                  xx101110xx1x1xx1100010xxxxxxxxxx
18790                                                                  frinta.  */
18791                                                               return 231;
18792                                                             }
18793                                                         }
18794                                                     }
18795                                                 }
18796                                               else
18797                                                 {
18798                                                   if (((word >> 23) & 0x1) == 0)
18799                                                     {
18800                                                       if (((word >> 29) & 0x1) == 0)
18801                                                         {
18802                                                           if (((word >> 31) & 0x1) == 0)
18803                                                             {
18804                                                               if (((word >> 16) & 0x1) == 0)
18805                                                                 {
18806                                                                   /* 33222222222211111111110000000000
18807                                                                      10987654321098765432109876543210
18808                                                                      0x0011100x1xxxx0110010xxxxxxxxxx
18809                                                                      fmaxnmv.  */
18810                                                                   return 37;
18811                                                                 }
18812                                                               else
18813                                                                 {
18814                                                                   if (((word >> 19) & 0x1) == 0)
18815                                                                     {
18816                                                                       /* 33222222222211111111110000000000
18817                                                                          10987654321098765432109876543210
18818                                                                          0x0011100x1x0xx1110010xxxxxxxxxx
18819                                                                          fcvtas.  */
18820                                                                       return 190;
18821                                                                     }
18822                                                                   else
18823                                                                     {
18824                                                                       /* 33222222222211111111110000000000
18825                                                                          10987654321098765432109876543210
18826                                                                          0x0011100x1x1xx1110010xxxxxxxxxx
18827                                                                          fcvtas.  */
18828                                                                       return 191;
18829                                                                     }
18830                                                                 }
18831                                                             }
18832                                                           else
18833                                                             {
18834                                                               /* 33222222222211111111110000000000
18835                                                                  10987654321098765432109876543210
18836                                                                  1x0011100x1xxxxx110010xxxxxxxxxx
18837                                                                  sm4ekey.  */
18838                                                               return 2361;
18839                                                             }
18840                                                         }
18841                                                       else
18842                                                         {
18843                                                           if (((word >> 16) & 0x1) == 0)
18844                                                             {
18845                                                               /* 33222222222211111111110000000000
18846                                                                  10987654321098765432109876543210
18847                                                                  xx1011100x1xxxx0110010xxxxxxxxxx
18848                                                                  fmaxnmv.  */
18849                                                               return 36;
18850                                                             }
18851                                                           else
18852                                                             {
18853                                                               if (((word >> 19) & 0x1) == 0)
18854                                                                 {
18855                                                                   /* 33222222222211111111110000000000
18856                                                                      10987654321098765432109876543210
18857                                                                      xx1011100x1x0xx1110010xxxxxxxxxx
18858                                                                      fcvtau.  */
18859                                                                   return 238;
18860                                                                 }
18861                                                               else
18862                                                                 {
18863                                                                   /* 33222222222211111111110000000000
18864                                                                      10987654321098765432109876543210
18865                                                                      xx1011100x1x1xx1110010xxxxxxxxxx
18866                                                                      fcvtau.  */
18867                                                                   return 239;
18868                                                                 }
18869                                                             }
18870                                                         }
18871                                                     }
18872                                                   else
18873                                                     {
18874                                                       if (((word >> 16) & 0x1) == 0)
18875                                                         {
18876                                                           if (((word >> 19) & 0x1) == 0)
18877                                                             {
18878                                                               if (((word >> 20) & 0x1) == 0)
18879                                                                 {
18880                                                                   if (((word >> 29) & 0x1) == 0)
18881                                                                     {
18882                                                                       /* 33222222222211111111110000000000
18883                                                                          10987654321098765432109876543210
18884                                                                          xx0011101x100xx0110010xxxxxxxxxx
18885                                                                          fcmgt.  */
18886                                                                       return 194;
18887                                                                     }
18888                                                                   else
18889                                                                     {
18890                                                                       /* 33222222222211111111110000000000
18891                                                                          10987654321098765432109876543210
18892                                                                          xx1011101x100xx0110010xxxxxxxxxx
18893                                                                          fcmge.  */
18894                                                                       return 245;
18895                                                                     }
18896                                                                 }
18897                                                               else
18898                                                                 {
18899                                                                   if (((word >> 29) & 0x1) == 0)
18900                                                                     {
18901                                                                       /* 33222222222211111111110000000000
18902                                                                          10987654321098765432109876543210
18903                                                                          xx0011101x110xx0110010xxxxxxxxxx
18904                                                                          fminnmv.  */
18905                                                                       return 41;
18906                                                                     }
18907                                                                   else
18908                                                                     {
18909                                                                       /* 33222222222211111111110000000000
18910                                                                          10987654321098765432109876543210
18911                                                                          xx1011101x110xx0110010xxxxxxxxxx
18912                                                                          fminnmv.  */
18913                                                                       return 40;
18914                                                                     }
18915                                                                 }
18916                                                             }
18917                                                           else
18918                                                             {
18919                                                               if (((word >> 29) & 0x1) == 0)
18920                                                                 {
18921                                                                   /* 33222222222211111111110000000000
18922                                                                      10987654321098765432109876543210
18923                                                                      xx0011101x1x1xx0110010xxxxxxxxxx
18924                                                                      fcmgt.  */
18925                                                                   return 195;
18926                                                                 }
18927                                                               else
18928                                                                 {
18929                                                                   /* 33222222222211111111110000000000
18930                                                                      10987654321098765432109876543210
18931                                                                      xx1011101x1x1xx0110010xxxxxxxxxx
18932                                                                      fcmge.  */
18933                                                                   return 246;
18934                                                                 }
18935                                                             }
18936                                                         }
18937                                                       else
18938                                                         {
18939                                                           if (((word >> 29) & 0x1) == 0)
18940                                                             {
18941                                                               /* 33222222222211111111110000000000
18942                                                                  10987654321098765432109876543210
18943                                                                  xx0011101x1xxxx1110010xxxxxxxxxx
18944                                                                  urecpe.  */
18945                                                               return 210;
18946                                                             }
18947                                                           else
18948                                                             {
18949                                                               /* 33222222222211111111110000000000
18950                                                                  10987654321098765432109876543210
18951                                                                  xx1011101x1xxxx1110010xxxxxxxxxx
18952                                                                  ursqrte.  */
18953                                                               return 257;
18954                                                             }
18955                                                         }
18956                                                     }
18957                                                 }
18958                                             }
18959                                           else
18960                                             {
18961                                               if (((word >> 14) & 0x1) == 0)
18962                                                 {
18963                                                   if (((word >> 16) & 0x1) == 0)
18964                                                     {
18965                                                       if (((word >> 20) & 0x1) == 0)
18966                                                         {
18967                                                           /* 33222222222211111111110000000000
18968                                                              10987654321098765432109876543210
18969                                                              xxx01110xx10xxx0101010xxxxxxxxxx
18970                                                              cmlt.  */
18971                                                           return 172;
18972                                                         }
18973                                                       else
18974                                                         {
18975                                                           if (((word >> 29) & 0x1) == 0)
18976                                                             {
18977                                                               /* 33222222222211111111110000000000
18978                                                                  10987654321098765432109876543210
18979                                                                  xx001110xx11xxx0101010xxxxxxxxxx
18980                                                                  smaxv.  */
18981                                                               return 30;
18982                                                             }
18983                                                           else
18984                                                             {
18985                                                               /* 33222222222211111111110000000000
18986                                                                  10987654321098765432109876543210
18987                                                                  xx101110xx11xxx0101010xxxxxxxxxx
18988                                                                  umaxv.  */
18989                                                               return 34;
18990                                                             }
18991                                                         }
18992                                                     }
18993                                                   else
18994                                                     {
18995                                                       if (((word >> 19) & 0x1) == 0)
18996                                                         {
18997                                                           if (((word >> 20) & 0x1) == 0)
18998                                                             {
18999                                                               if (((word >> 23) & 0x1) == 0)
19000                                                                 {
19001                                                                   if (((word >> 29) & 0x1) == 0)
19002                                                                     {
19003                                                                       /* 33222222222211111111110000000000
19004                                                                          10987654321098765432109876543210
19005                                                                          xx0011100x100xx1101010xxxxxxxxxx
19006                                                                          fcvtns.  */
19007                                                                       return 186;
19008                                                                     }
19009                                                                   else
19010                                                                     {
19011                                                                       /* 33222222222211111111110000000000
19012                                                                          10987654321098765432109876543210
19013                                                                          xx1011100x100xx1101010xxxxxxxxxx
19014                                                                          fcvtnu.  */
19015                                                                       return 234;
19016                                                                     }
19017                                                                 }
19018                                                               else
19019                                                                 {
19020                                                                   if (((word >> 29) & 0x1) == 0)
19021                                                                     {
19022                                                                       /* 33222222222211111111110000000000
19023                                                                          10987654321098765432109876543210
19024                                                                          xx0011101x100xx1101010xxxxxxxxxx
19025                                                                          fcvtps.  */
19026                                                                       return 206;
19027                                                                     }
19028                                                                   else
19029                                                                     {
19030                                                                       /* 33222222222211111111110000000000
19031                                                                          10987654321098765432109876543210
19032                                                                          xx1011101x100xx1101010xxxxxxxxxx
19033                                                                          fcvtpu.  */
19034                                                                       return 253;
19035                                                                     }
19036                                                                 }
19037                                                             }
19038                                                           else
19039                                                             {
19040                                                               if (((word >> 29) & 0x1) == 0)
19041                                                                 {
19042                                                                   /* 33222222222211111111110000000000
19043                                                                      10987654321098765432109876543210
19044                                                                      xx001110xx110xx1101010xxxxxxxxxx
19045                                                                      sminv.  */
19046                                                                   return 31;
19047                                                                 }
19048                                                               else
19049                                                                 {
19050                                                                   /* 33222222222211111111110000000000
19051                                                                      10987654321098765432109876543210
19052                                                                      xx101110xx110xx1101010xxxxxxxxxx
19053                                                                      uminv.  */
19054                                                                   return 35;
19055                                                                 }
19056                                                             }
19057                                                         }
19058                                                       else
19059                                                         {
19060                                                           if (((word >> 23) & 0x1) == 0)
19061                                                             {
19062                                                               if (((word >> 29) & 0x1) == 0)
19063                                                                 {
19064                                                                   /* 33222222222211111111110000000000
19065                                                                      10987654321098765432109876543210
19066                                                                      xx0011100x1x1xx1101010xxxxxxxxxx
19067                                                                      fcvtns.  */
19068                                                                   return 187;
19069                                                                 }
19070                                                               else
19071                                                                 {
19072                                                                   /* 33222222222211111111110000000000
19073                                                                      10987654321098765432109876543210
19074                                                                      xx1011100x1x1xx1101010xxxxxxxxxx
19075                                                                      fcvtnu.  */
19076                                                                   return 235;
19077                                                                 }
19078                                                             }
19079                                                           else
19080                                                             {
19081                                                               if (((word >> 29) & 0x1) == 0)
19082                                                                 {
19083                                                                   /* 33222222222211111111110000000000
19084                                                                      10987654321098765432109876543210
19085                                                                      xx0011101x1x1xx1101010xxxxxxxxxx
19086                                                                      fcvtps.  */
19087                                                                   return 207;
19088                                                                 }
19089                                                               else
19090                                                                 {
19091                                                                   /* 33222222222211111111110000000000
19092                                                                      10987654321098765432109876543210
19093                                                                      xx1011101x1x1xx1101010xxxxxxxxxx
19094                                                                      fcvtpu.  */
19095                                                                   return 254;
19096                                                                 }
19097                                                             }
19098                                                         }
19099                                                     }
19100                                                 }
19101                                               else
19102                                                 {
19103                                                   if (((word >> 16) & 0x1) == 0)
19104                                                     {
19105                                                       if (((word >> 19) & 0x1) == 0)
19106                                                         {
19107                                                           /* 33222222222211111111110000000000
19108                                                              10987654321098765432109876543210
19109                                                              xxx01110xx1x0xx0111010xxxxxxxxxx
19110                                                              fcmlt.  */
19111                                                           return 198;
19112                                                         }
19113                                                       else
19114                                                         {
19115                                                           /* 33222222222211111111110000000000
19116                                                              10987654321098765432109876543210
19117                                                              xxx01110xx1x1xx0111010xxxxxxxxxx
19118                                                              fcmlt.  */
19119                                                           return 199;
19120                                                         }
19121                                                     }
19122                                                   else
19123                                                     {
19124                                                       if (((word >> 29) & 0x1) == 0)
19125                                                         {
19126                                                           /* 33222222222211111111110000000000
19127                                                              10987654321098765432109876543210
19128                                                              xx001110xx1xxxx1111010xxxxxxxxxx
19129                                                              frint32z.  */
19130                                                           return 158;
19131                                                         }
19132                                                       else
19133                                                         {
19134                                                           /* 33222222222211111111110000000000
19135                                                              10987654321098765432109876543210
19136                                                              xx101110xx1xxxx1111010xxxxxxxxxx
19137                                                              frint32x.  */
19138                                                           return 159;
19139                                                         }
19140                                                     }
19141                                                 }
19142                                             }
19143                                         }
19144                                       else
19145                                         {
19146                                           if (((word >> 13) & 0x1) == 0)
19147                                             {
19148                                               if (((word >> 14) & 0x1) == 0)
19149                                                 {
19150                                                   if (((word >> 16) & 0x1) == 0)
19151                                                     {
19152                                                       if (((word >> 29) & 0x1) == 0)
19153                                                         {
19154                                                           /* 33222222222211111111110000000000
19155                                                              10987654321098765432109876543210
19156                                                              xx001110xx1xxxx0100110xxxxxxxxxx
19157                                                              cmeq.  */
19158                                                           return 171;
19159                                                         }
19160                                                       else
19161                                                         {
19162                                                           /* 33222222222211111111110000000000
19163                                                              10987654321098765432109876543210
19164                                                              xx101110xx1xxxx0100110xxxxxxxxxx
19165                                                              cmle.  */
19166                                                           return 220;
19167                                                         }
19168                                                     }
19169                                                   else
19170                                                     {
19171                                                       if (((word >> 19) & 0x1) == 0)
19172                                                         {
19173                                                           if (((word >> 23) & 0x1) == 0)
19174                                                             {
19175                                                               if (((word >> 29) & 0x1) == 0)
19176                                                                 {
19177                                                                   /* 33222222222211111111110000000000
19178                                                                      10987654321098765432109876543210
19179                                                                      xx0011100x1x0xx1100110xxxxxxxxxx
19180                                                                      frintm.  */
19181                                                                   return 184;
19182                                                                 }
19183                                                               else
19184                                                                 {
19185                                                                   /* 33222222222211111111110000000000
19186                                                                      10987654321098765432109876543210
19187                                                                      xx1011100x1x0xx1100110xxxxxxxxxx
19188                                                                      frintx.  */
19189                                                                   return 232;
19190                                                                 }
19191                                                             }
19192                                                           else
19193                                                             {
19194                                                               if (((word >> 29) & 0x1) == 0)
19195                                                                 {
19196                                                                   /* 33222222222211111111110000000000
19197                                                                      10987654321098765432109876543210
19198                                                                      xx0011101x1x0xx1100110xxxxxxxxxx
19199                                                                      frintz.  */
19200                                                                   return 204;
19201                                                                 }
19202                                                               else
19203                                                                 {
19204                                                                   /* 33222222222211111111110000000000
19205                                                                      10987654321098765432109876543210
19206                                                                      xx1011101x1x0xx1100110xxxxxxxxxx
19207                                                                      frinti.  */
19208                                                                   return 251;
19209                                                                 }
19210                                                             }
19211                                                         }
19212                                                       else
19213                                                         {
19214                                                           if (((word >> 23) & 0x1) == 0)
19215                                                             {
19216                                                               if (((word >> 29) & 0x1) == 0)
19217                                                                 {
19218                                                                   /* 33222222222211111111110000000000
19219                                                                      10987654321098765432109876543210
19220                                                                      xx0011100x1x1xx1100110xxxxxxxxxx
19221                                                                      frintm.  */
19222                                                                   return 185;
19223                                                                 }
19224                                                               else
19225                                                                 {
19226                                                                   /* 33222222222211111111110000000000
19227                                                                      10987654321098765432109876543210
19228                                                                      xx1011100x1x1xx1100110xxxxxxxxxx
19229                                                                      frintx.  */
19230                                                                   return 233;
19231                                                                 }
19232                                                             }
19233                                                           else
19234                                                             {
19235                                                               if (((word >> 29) & 0x1) == 0)
19236                                                                 {
19237                                                                   /* 33222222222211111111110000000000
19238                                                                      10987654321098765432109876543210
19239                                                                      xx0011101x1x1xx1100110xxxxxxxxxx
19240                                                                      frintz.  */
19241                                                                   return 205;
19242                                                                 }
19243                                                               else
19244                                                                 {
19245                                                                   /* 33222222222211111111110000000000
19246                                                                      10987654321098765432109876543210
19247                                                                      xx1011101x1x1xx1100110xxxxxxxxxx
19248                                                                      frinti.  */
19249                                                                   return 252;
19250                                                                 }
19251                                                             }
19252                                                         }
19253                                                     }
19254                                                 }
19255                                               else
19256                                                 {
19257                                                   if (((word >> 16) & 0x1) == 0)
19258                                                     {
19259                                                       if (((word >> 19) & 0x1) == 0)
19260                                                         {
19261                                                           if (((word >> 29) & 0x1) == 0)
19262                                                             {
19263                                                               /* 33222222222211111111110000000000
19264                                                                  10987654321098765432109876543210
19265                                                                  xx001110xx1x0xx0110110xxxxxxxxxx
19266                                                                  fcmeq.  */
19267                                                               return 196;
19268                                                             }
19269                                                           else
19270                                                             {
19271                                                               /* 33222222222211111111110000000000
19272                                                                  10987654321098765432109876543210
19273                                                                  xx101110xx1x0xx0110110xxxxxxxxxx
19274                                                                  fcmle.  */
19275                                                               return 247;
19276                                                             }
19277                                                         }
19278                                                       else
19279                                                         {
19280                                                           if (((word >> 29) & 0x1) == 0)
19281                                                             {
19282                                                               /* 33222222222211111111110000000000
19283                                                                  10987654321098765432109876543210
19284                                                                  xx001110xx1x1xx0110110xxxxxxxxxx
19285                                                                  fcmeq.  */
19286                                                               return 197;
19287                                                             }
19288                                                           else
19289                                                             {
19290                                                               /* 33222222222211111111110000000000
19291                                                                  10987654321098765432109876543210
19292                                                                  xx101110xx1x1xx0110110xxxxxxxxxx
19293                                                                  fcmle.  */
19294                                                               return 248;
19295                                                             }
19296                                                         }
19297                                                     }
19298                                                   else
19299                                                     {
19300                                                       if (((word >> 19) & 0x1) == 0)
19301                                                         {
19302                                                           if (((word >> 23) & 0x1) == 0)
19303                                                             {
19304                                                               if (((word >> 29) & 0x1) == 0)
19305                                                                 {
19306                                                                   /* 33222222222211111111110000000000
19307                                                                      10987654321098765432109876543210
19308                                                                      xx0011100x1x0xx1110110xxxxxxxxxx
19309                                                                      scvtf.  */
19310                                                                   return 192;
19311                                                                 }
19312                                                               else
19313                                                                 {
19314                                                                   /* 33222222222211111111110000000000
19315                                                                      10987654321098765432109876543210
19316                                                                      xx1011100x1x0xx1110110xxxxxxxxxx
19317                                                                      ucvtf.  */
19318                                                                   return 240;
19319                                                                 }
19320                                                             }
19321                                                           else
19322                                                             {
19323                                                               if (((word >> 29) & 0x1) == 0)
19324                                                                 {
19325                                                                   /* 33222222222211111111110000000000
19326                                                                      10987654321098765432109876543210
19327                                                                      xx0011101x1x0xx1110110xxxxxxxxxx
19328                                                                      frecpe.  */
19329                                                                   return 211;
19330                                                                 }
19331                                                               else
19332                                                                 {
19333                                                                   /* 33222222222211111111110000000000
19334                                                                      10987654321098765432109876543210
19335                                                                      xx1011101x1x0xx1110110xxxxxxxxxx
19336                                                                      frsqrte.  */
19337                                                                   return 258;
19338                                                                 }
19339                                                             }
19340                                                         }
19341                                                       else
19342                                                         {
19343                                                           if (((word >> 23) & 0x1) == 0)
19344                                                             {
19345                                                               if (((word >> 29) & 0x1) == 0)
19346                                                                 {
19347                                                                   /* 33222222222211111111110000000000
19348                                                                      10987654321098765432109876543210
19349                                                                      xx0011100x1x1xx1110110xxxxxxxxxx
19350                                                                      scvtf.  */
19351                                                                   return 193;
19352                                                                 }
19353                                                               else
19354                                                                 {
19355                                                                   /* 33222222222211111111110000000000
19356                                                                      10987654321098765432109876543210
19357                                                                      xx1011100x1x1xx1110110xxxxxxxxxx
19358                                                                      ucvtf.  */
19359                                                                   return 241;
19360                                                                 }
19361                                                             }
19362                                                           else
19363                                                             {
19364                                                               if (((word >> 29) & 0x1) == 0)
19365                                                                 {
19366                                                                   /* 33222222222211111111110000000000
19367                                                                      10987654321098765432109876543210
19368                                                                      xx0011101x1x1xx1110110xxxxxxxxxx
19369                                                                      frecpe.  */
19370                                                                   return 212;
19371                                                                 }
19372                                                               else
19373                                                                 {
19374                                                                   /* 33222222222211111111110000000000
19375                                                                      10987654321098765432109876543210
19376                                                                      xx1011101x1x1xx1110110xxxxxxxxxx
19377                                                                      frsqrte.  */
19378                                                                   return 259;
19379                                                                 }
19380                                                             }
19381                                                         }
19382                                                     }
19383                                                 }
19384                                             }
19385                                           else
19386                                             {
19387                                               if (((word >> 14) & 0x1) == 0)
19388                                                 {
19389                                                   if (((word >> 16) & 0x1) == 0)
19390                                                     {
19391                                                       if (((word >> 29) & 0x1) == 0)
19392                                                         {
19393                                                           /* 33222222222211111111110000000000
19394                                                              10987654321098765432109876543210
19395                                                              xx001110xx1xxxx0101110xxxxxxxxxx
19396                                                              abs.  */
19397                                                           return 173;
19398                                                         }
19399                                                       else
19400                                                         {
19401                                                           /* 33222222222211111111110000000000
19402                                                              10987654321098765432109876543210
19403                                                              xx101110xx1xxxx0101110xxxxxxxxxx
19404                                                              neg.  */
19405                                                           return 221;
19406                                                         }
19407                                                     }
19408                                                   else
19409                                                     {
19410                                                       if (((word >> 19) & 0x1) == 0)
19411                                                         {
19412                                                           if (((word >> 20) & 0x1) == 0)
19413                                                             {
19414                                                               if (((word >> 23) & 0x1) == 0)
19415                                                                 {
19416                                                                   if (((word >> 29) & 0x1) == 0)
19417                                                                     {
19418                                                                       /* 33222222222211111111110000000000
19419                                                                          10987654321098765432109876543210
19420                                                                          xx0011100x100xx1101110xxxxxxxxxx
19421                                                                          fcvtms.  */
19422                                                                       return 188;
19423                                                                     }
19424                                                                   else
19425                                                                     {
19426                                                                       /* 33222222222211111111110000000000
19427                                                                          10987654321098765432109876543210
19428                                                                          xx1011100x100xx1101110xxxxxxxxxx
19429                                                                          fcvtmu.  */
19430                                                                       return 236;
19431                                                                     }
19432                                                                 }
19433                                                               else
19434                                                                 {
19435                                                                   if (((word >> 29) & 0x1) == 0)
19436                                                                     {
19437                                                                       /* 33222222222211111111110000000000
19438                                                                          10987654321098765432109876543210
19439                                                                          xx0011101x100xx1101110xxxxxxxxxx
19440                                                                          fcvtzs.  */
19441                                                                       return 208;
19442                                                                     }
19443                                                                   else
19444                                                                     {
19445                                                                       /* 33222222222211111111110000000000
19446                                                                          10987654321098765432109876543210
19447                                                                          xx1011101x100xx1101110xxxxxxxxxx
19448                                                                          fcvtzu.  */
19449                                                                       return 255;
19450                                                                     }
19451                                                                 }
19452                                                             }
19453                                                           else
19454                                                             {
19455                                                               /* 33222222222211111111110000000000
19456                                                                  10987654321098765432109876543210
19457                                                                  xxx01110xx110xx1101110xxxxxxxxxx
19458                                                                  addv.  */
19459                                                               return 32;
19460                                                             }
19461                                                         }
19462                                                       else
19463                                                         {
19464                                                           if (((word >> 23) & 0x1) == 0)
19465                                                             {
19466                                                               if (((word >> 29) & 0x1) == 0)
19467                                                                 {
19468                                                                   /* 33222222222211111111110000000000
19469                                                                      10987654321098765432109876543210
19470                                                                      xx0011100x1x1xx1101110xxxxxxxxxx
19471                                                                      fcvtms.  */
19472                                                                   return 189;
19473                                                                 }
19474                                                               else
19475                                                                 {
19476                                                                   /* 33222222222211111111110000000000
19477                                                                      10987654321098765432109876543210
19478                                                                      xx1011100x1x1xx1101110xxxxxxxxxx
19479                                                                      fcvtmu.  */
19480                                                                   return 237;
19481                                                                 }
19482                                                             }
19483                                                           else
19484                                                             {
19485                                                               if (((word >> 29) & 0x1) == 0)
19486                                                                 {
19487                                                                   /* 33222222222211111111110000000000
19488                                                                      10987654321098765432109876543210
19489                                                                      xx0011101x1x1xx1101110xxxxxxxxxx
19490                                                                      fcvtzs.  */
19491                                                                   return 209;
19492                                                                 }
19493                                                               else
19494                                                                 {
19495                                                                   /* 33222222222211111111110000000000
19496                                                                      10987654321098765432109876543210
19497                                                                      xx1011101x1x1xx1101110xxxxxxxxxx
19498                                                                      fcvtzu.  */
19499                                                                   return 256;
19500                                                                 }
19501                                                             }
19502                                                         }
19503                                                     }
19504                                                 }
19505                                               else
19506                                                 {
19507                                                   if (((word >> 16) & 0x1) == 0)
19508                                                     {
19509                                                       if (((word >> 19) & 0x1) == 0)
19510                                                         {
19511                                                           if (((word >> 20) & 0x1) == 0)
19512                                                             {
19513                                                               if (((word >> 29) & 0x1) == 0)
19514                                                                 {
19515                                                                   /* 33222222222211111111110000000000
19516                                                                      10987654321098765432109876543210
19517                                                                      xx001110xx100xx0111110xxxxxxxxxx
19518                                                                      fabs.  */
19519                                                                   return 200;
19520                                                                 }
19521                                                               else
19522                                                                 {
19523                                                                   /* 33222222222211111111110000000000
19524                                                                      10987654321098765432109876543210
19525                                                                      xx101110xx100xx0111110xxxxxxxxxx
19526                                                                      fneg.  */
19527                                                                   return 249;
19528                                                                 }
19529                                                             }
19530                                                           else
19531                                                             {
19532                                                               if (((word >> 23) & 0x1) == 0)
19533                                                                 {
19534                                                                   if (((word >> 29) & 0x1) == 0)
19535                                                                     {
19536                                                                       /* 33222222222211111111110000000000
19537                                                                          10987654321098765432109876543210
19538                                                                          xx0011100x110xx0111110xxxxxxxxxx
19539                                                                          fmaxv.  */
19540                                                                       return 39;
19541                                                                     }
19542                                                                   else
19543                                                                     {
19544                                                                       /* 33222222222211111111110000000000
19545                                                                          10987654321098765432109876543210
19546                                                                          xx1011100x110xx0111110xxxxxxxxxx
19547                                                                          fmaxv.  */
19548                                                                       return 38;
19549                                                                     }
19550                                                                 }
19551                                                               else
19552                                                                 {
19553                                                                   if (((word >> 29) & 0x1) == 0)
19554                                                                     {
19555                                                                       /* 33222222222211111111110000000000
19556                                                                          10987654321098765432109876543210
19557                                                                          xx0011101x110xx0111110xxxxxxxxxx
19558                                                                          fminv.  */
19559                                                                       return 43;
19560                                                                     }
19561                                                                   else
19562                                                                     {
19563                                                                       /* 33222222222211111111110000000000
19564                                                                          10987654321098765432109876543210
19565                                                                          xx1011101x110xx0111110xxxxxxxxxx
19566                                                                          fminv.  */
19567                                                                       return 42;
19568                                                                     }
19569                                                                 }
19570                                                             }
19571                                                         }
19572                                                       else
19573                                                         {
19574                                                           if (((word >> 29) & 0x1) == 0)
19575                                                             {
19576                                                               /* 33222222222211111111110000000000
19577                                                                  10987654321098765432109876543210
19578                                                                  xx001110xx1x1xx0111110xxxxxxxxxx
19579                                                                  fabs.  */
19580                                                               return 201;
19581                                                             }
19582                                                           else
19583                                                             {
19584                                                               /* 33222222222211111111110000000000
19585                                                                  10987654321098765432109876543210
19586                                                                  xx101110xx1x1xx0111110xxxxxxxxxx
19587                                                                  fneg.  */
19588                                                               return 250;
19589                                                             }
19590                                                         }
19591                                                     }
19592                                                   else
19593                                                     {
19594                                                       if (((word >> 19) & 0x1) == 0)
19595                                                         {
19596                                                           if (((word >> 23) & 0x1) == 0)
19597                                                             {
19598                                                               if (((word >> 29) & 0x1) == 0)
19599                                                                 {
19600                                                                   /* 33222222222211111111110000000000
19601                                                                      10987654321098765432109876543210
19602                                                                      xx0011100x1x0xx1111110xxxxxxxxxx
19603                                                                      frint64z.  */
19604                                                                   return 160;
19605                                                                 }
19606                                                               else
19607                                                                 {
19608                                                                   /* 33222222222211111111110000000000
19609                                                                      10987654321098765432109876543210
19610                                                                      xx1011100x1x0xx1111110xxxxxxxxxx
19611                                                                      frint64x.  */
19612                                                                   return 161;
19613                                                                 }
19614                                                             }
19615                                                           else
19616                                                             {
19617                                                               /* 33222222222211111111110000000000
19618                                                                  10987654321098765432109876543210
19619                                                                  xxx011101x1x0xx1111110xxxxxxxxxx
19620                                                                  fsqrt.  */
19621                                                               return 260;
19622                                                             }
19623                                                         }
19624                                                       else
19625                                                         {
19626                                                           /* 33222222222211111111110000000000
19627                                                              10987654321098765432109876543210
19628                                                              xxx01110xx1x1xx1111110xxxxxxxxxx
19629                                                              fsqrt.  */
19630                                                           return 261;
19631                                                         }
19632                                                     }
19633                                                 }
19634                                             }
19635                                         }
19636                                     }
19637                                 }
19638                               else
19639                                 {
19640                                   if (((word >> 11) & 0x1) == 0)
19641                                     {
19642                                       if (((word >> 12) & 0x1) == 0)
19643                                         {
19644                                           if (((word >> 13) & 0x1) == 0)
19645                                             {
19646                                               if (((word >> 14) & 0x1) == 0)
19647                                                 {
19648                                                   if (((word >> 29) & 0x1) == 0)
19649                                                     {
19650                                                       if (((word >> 31) & 0x1) == 0)
19651                                                         {
19652                                                           /* 33222222222211111111110000000000
19653                                                              10987654321098765432109876543210
19654                                                              0x001110xx1xxxxx100001xxxxxxxxxx
19655                                                              add.  */
19656                                                           return 283;
19657                                                         }
19658                                                       else
19659                                                         {
19660                                                           /* 33222222222211111111110000000000
19661                                                              10987654321098765432109876543210
19662                                                              1x001110xx1xxxxx100001xxxxxxxxxx
19663                                                              sha512h2.  */
19664                                                           return 2346;
19665                                                         }
19666                                                     }
19667                                                   else
19668                                                     {
19669                                                       /* 33222222222211111111110000000000
19670                                                          10987654321098765432109876543210
19671                                                          xx101110xx1xxxxx100001xxxxxxxxxx
19672                                                          sub.  */
19673                                                       return 335;
19674                                                     }
19675                                                 }
19676                                               else
19677                                                 {
19678                                                   if (((word >> 23) & 0x1) == 0)
19679                                                     {
19680                                                       if (((word >> 29) & 0x1) == 0)
19681                                                         {
19682                                                           if (((word >> 31) & 0x1) == 0)
19683                                                             {
19684                                                               /* 33222222222211111111110000000000
19685                                                                  10987654321098765432109876543210
19686                                                                  0x0011100x1xxxxx110001xxxxxxxxxx
19687                                                                  fmaxnm.  */
19688                                                               return 291;
19689                                                             }
19690                                                           else
19691                                                             {
19692                                                               /* 33222222222211111111110000000000
19693                                                                  10987654321098765432109876543210
19694                                                                  1x0011100x1xxxxx110001xxxxxxxxxx
19695                                                                  sm3partw2.  */
19696                                                               return 2359;
19697                                                             }
19698                                                         }
19699                                                       else
19700                                                         {
19701                                                           /* 33222222222211111111110000000000
19702                                                              10987654321098765432109876543210
19703                                                              xx1011100x1xxxxx110001xxxxxxxxxx
19704                                                              fmaxnmp.  */
19705                                                           return 342;
19706                                                         }
19707                                                     }
19708                                                   else
19709                                                     {
19710                                                       if (((word >> 29) & 0x1) == 0)
19711                                                         {
19712                                                           /* 33222222222211111111110000000000
19713                                                              10987654321098765432109876543210
19714                                                              xx0011101x1xxxxx110001xxxxxxxxxx
19715                                                              fminnm.  */
19716                                                           return 307;
19717                                                         }
19718                                                       else
19719                                                         {
19720                                                           /* 33222222222211111111110000000000
19721                                                              10987654321098765432109876543210
19722                                                              xx1011101x1xxxxx110001xxxxxxxxxx
19723                                                              fminnmp.  */
19724                                                           return 358;
19725                                                         }
19726                                                     }
19727                                                 }
19728                                             }
19729                                           else
19730                                             {
19731                                               if (((word >> 14) & 0x1) == 0)
19732                                                 {
19733                                                   if (((word >> 29) & 0x1) == 0)
19734                                                     {
19735                                                       /* 33222222222211111111110000000000
19736                                                          10987654321098765432109876543210
19737                                                          xx001110xx1xxxxx101001xxxxxxxxxx
19738                                                          smaxp.  */
19739                                                       return 287;
19740                                                     }
19741                                                   else
19742                                                     {
19743                                                       /* 33222222222211111111110000000000
19744                                                          10987654321098765432109876543210
19745                                                          xx101110xx1xxxxx101001xxxxxxxxxx
19746                                                          umaxp.  */
19747                                                       return 339;
19748                                                     }
19749                                                 }
19750                                               else
19751                                                 {
19752                                                   if (((word >> 23) & 0x1) == 0)
19753                                                     {
19754                                                       if (((word >> 29) & 0x1) == 0)
19755                                                         {
19756                                                           /* 33222222222211111111110000000000
19757                                                              10987654321098765432109876543210
19758                                                              xx0011100x1xxxxx111001xxxxxxxxxx
19759                                                              fcmeq.  */
19760                                                           return 299;
19761                                                         }
19762                                                       else
19763                                                         {
19764                                                           /* 33222222222211111111110000000000
19765                                                              10987654321098765432109876543210
19766                                                              xx1011100x1xxxxx111001xxxxxxxxxx
19767                                                              fcmge.  */
19768                                                           return 348;
19769                                                         }
19770                                                     }
19771                                                   else
19772                                                     {
19773                                                       /* 33222222222211111111110000000000
19774                                                          10987654321098765432109876543210
19775                                                          xxx011101x1xxxxx111001xxxxxxxxxx
19776                                                          fcmgt.  */
19777                                                       return 362;
19778                                                     }
19779                                                 }
19780                                             }
19781                                         }
19782                                       else
19783                                         {
19784                                           if (((word >> 13) & 0x1) == 0)
19785                                             {
19786                                               if (((word >> 14) & 0x1) == 0)
19787                                                 {
19788                                                   if (((word >> 29) & 0x1) == 0)
19789                                                     {
19790                                                       /* 33222222222211111111110000000000
19791                                                          10987654321098765432109876543210
19792                                                          xx001110xx1xxxxx100101xxxxxxxxxx
19793                                                          mla.  */
19794                                                       return 285;
19795                                                     }
19796                                                   else
19797                                                     {
19798                                                       /* 33222222222211111111110000000000
19799                                                          10987654321098765432109876543210
19800                                                          xx101110xx1xxxxx100101xxxxxxxxxx
19801                                                          mls.  */
19802                                                       return 337;
19803                                                     }
19804                                                 }
19805                                               else
19806                                                 {
19807                                                   if (((word >> 23) & 0x1) == 0)
19808                                                     {
19809                                                       if (((word >> 29) & 0x1) == 0)
19810                                                         {
19811                                                           /* 33222222222211111111110000000000
19812                                                              10987654321098765432109876543210
19813                                                              xx0011100x1xxxxx110101xxxxxxxxxx
19814                                                              fadd.  */
19815                                                           return 295;
19816                                                         }
19817                                                       else
19818                                                         {
19819                                                           /* 33222222222211111111110000000000
19820                                                              10987654321098765432109876543210
19821                                                              xx1011100x1xxxxx110101xxxxxxxxxx
19822                                                              faddp.  */
19823                                                           return 344;
19824                                                         }
19825                                                     }
19826                                                   else
19827                                                     {
19828                                                       if (((word >> 29) & 0x1) == 0)
19829                                                         {
19830                                                           /* 33222222222211111111110000000000
19831                                                              10987654321098765432109876543210
19832                                                              xx0011101x1xxxxx110101xxxxxxxxxx
19833                                                              fsub.  */
19834                                                           return 311;
19835                                                         }
19836                                                       else
19837                                                         {
19838                                                           /* 33222222222211111111110000000000
19839                                                              10987654321098765432109876543210
19840                                                              xx1011101x1xxxxx110101xxxxxxxxxx
19841                                                              fabd.  */
19842                                                           return 360;
19843                                                         }
19844                                                     }
19845                                                 }
19846                                             }
19847                                           else
19848                                             {
19849                                               if (((word >> 14) & 0x1) == 0)
19850                                                 {
19851                                                   if (((word >> 29) & 0x1) == 0)
19852                                                     {
19853                                                       /* 33222222222211111111110000000000
19854                                                          10987654321098765432109876543210
19855                                                          xx001110xx1xxxxx101101xxxxxxxxxx
19856                                                          sqdmulh.  */
19857                                                       return 289;
19858                                                     }
19859                                                   else
19860                                                     {
19861                                                       /* 33222222222211111111110000000000
19862                                                          10987654321098765432109876543210
19863                                                          xx101110xx1xxxxx101101xxxxxxxxxx
19864                                                          sqrdmulh.  */
19865                                                       return 341;
19866                                                     }
19867                                                 }
19868                                               else
19869                                                 {
19870                                                   if (((word >> 23) & 0x1) == 0)
19871                                                     {
19872                                                       if (((word >> 29) & 0x1) == 0)
19873                                                         {
19874                                                           /* 33222222222211111111110000000000
19875                                                              10987654321098765432109876543210
19876                                                              xx0011100x1xxxxx111101xxxxxxxxxx
19877                                                              fmax.  */
19878                                                           return 301;
19879                                                         }
19880                                                       else
19881                                                         {
19882                                                           /* 33222222222211111111110000000000
19883                                                              10987654321098765432109876543210
19884                                                              xx1011100x1xxxxx111101xxxxxxxxxx
19885                                                              fmaxp.  */
19886                                                           return 352;
19887                                                         }
19888                                                     }
19889                                                   else
19890                                                     {
19891                                                       if (((word >> 29) & 0x1) == 0)
19892                                                         {
19893                                                           /* 33222222222211111111110000000000
19894                                                              10987654321098765432109876543210
19895                                                              xx0011101x1xxxxx111101xxxxxxxxxx
19896                                                              fmin.  */
19897                                                           return 313;
19898                                                         }
19899                                                       else
19900                                                         {
19901                                                           /* 33222222222211111111110000000000
19902                                                              10987654321098765432109876543210
19903                                                              xx1011101x1xxxxx111101xxxxxxxxxx
19904                                                              fminp.  */
19905                                                           return 366;
19906                                                         }
19907                                                     }
19908                                                 }
19909                                             }
19910                                         }
19911                                     }
19912                                   else
19913                                     {
19914                                       if (((word >> 12) & 0x1) == 0)
19915                                         {
19916                                           if (((word >> 13) & 0x1) == 0)
19917                                             {
19918                                               if (((word >> 14) & 0x1) == 0)
19919                                                 {
19920                                                   if (((word >> 29) & 0x1) == 0)
19921                                                     {
19922                                                       if (((word >> 31) & 0x1) == 0)
19923                                                         {
19924                                                           /* 33222222222211111111110000000000
19925                                                              10987654321098765432109876543210
19926                                                              0x001110xx1xxxxx100011xxxxxxxxxx
19927                                                              cmtst.  */
19928                                                           return 284;
19929                                                         }
19930                                                       else
19931                                                         {
19932                                                           /* 33222222222211111111110000000000
19933                                                              10987654321098765432109876543210
19934                                                              1x001110xx1xxxxx100011xxxxxxxxxx
19935                                                              rax1.  */
19936                                                           return 2350;
19937                                                         }
19938                                                     }
19939                                                   else
19940                                                     {
19941                                                       /* 33222222222211111111110000000000
19942                                                          10987654321098765432109876543210
19943                                                          xx101110xx1xxxxx100011xxxxxxxxxx
19944                                                          cmeq.  */
19945                                                       return 336;
19946                                                     }
19947                                                 }
19948                                               else
19949                                                 {
19950                                                   if (((word >> 23) & 0x1) == 0)
19951                                                     {
19952                                                       if (((word >> 29) & 0x1) == 0)
19953                                                         {
19954                                                           /* 33222222222211111111110000000000
19955                                                              10987654321098765432109876543210
19956                                                              xx0011100x1xxxxx110011xxxxxxxxxx
19957                                                              fmla.  */
19958                                                           return 293;
19959                                                         }
19960                                                       else
19961                                                         {
19962                                                           if (((word >> 30) & 0x1) == 0)
19963                                                             {
19964                                                               /* 33222222222211111111110000000000
19965                                                                  10987654321098765432109876543210
19966                                                                  x01011100x1xxxxx110011xxxxxxxxxx
19967                                                                  fmlal2.  */
19968                                                               return 2364;
19969                                                             }
19970                                                           else
19971                                                             {
19972                                                               /* 33222222222211111111110000000000
19973                                                                  10987654321098765432109876543210
19974                                                                  x11011100x1xxxxx110011xxxxxxxxxx
19975                                                                  fmlal2.  */
19976                                                               return 2368;
19977                                                             }
19978                                                         }
19979                                                     }
19980                                                   else
19981                                                     {
19982                                                       if (((word >> 29) & 0x1) == 0)
19983                                                         {
19984                                                           /* 33222222222211111111110000000000
19985                                                              10987654321098765432109876543210
19986                                                              xx0011101x1xxxxx110011xxxxxxxxxx
19987                                                              fmls.  */
19988                                                           return 309;
19989                                                         }
19990                                                       else
19991                                                         {
19992                                                           if (((word >> 30) & 0x1) == 0)
19993                                                             {
19994                                                               /* 33222222222211111111110000000000
19995                                                                  10987654321098765432109876543210
19996                                                                  x01011101x1xxxxx110011xxxxxxxxxx
19997                                                                  fmlsl2.  */
19998                                                               return 2365;
19999                                                             }
20000                                                           else
20001                                                             {
20002                                                               /* 33222222222211111111110000000000
20003                                                                  10987654321098765432109876543210
20004                                                                  x11011101x1xxxxx110011xxxxxxxxxx
20005                                                                  fmlsl2.  */
20006                                                               return 2369;
20007                                                             }
20008                                                         }
20009                                                     }
20010                                                 }
20011                                             }
20012                                           else
20013                                             {
20014                                               if (((word >> 14) & 0x1) == 0)
20015                                                 {
20016                                                   if (((word >> 29) & 0x1) == 0)
20017                                                     {
20018                                                       /* 33222222222211111111110000000000
20019                                                          10987654321098765432109876543210
20020                                                          xx001110xx1xxxxx101011xxxxxxxxxx
20021                                                          sminp.  */
20022                                                       return 288;
20023                                                     }
20024                                                   else
20025                                                     {
20026                                                       /* 33222222222211111111110000000000
20027                                                          10987654321098765432109876543210
20028                                                          xx101110xx1xxxxx101011xxxxxxxxxx
20029                                                          uminp.  */
20030                                                       return 340;
20031                                                     }
20032                                                 }
20033                                               else
20034                                                 {
20035                                                   if (((word >> 23) & 0x1) == 0)
20036                                                     {
20037                                                       if (((word >> 29) & 0x1) == 0)
20038                                                         {
20039                                                           if (((word >> 30) & 0x1) == 0)
20040                                                             {
20041                                                               /* 33222222222211111111110000000000
20042                                                                  10987654321098765432109876543210
20043                                                                  x00011100x1xxxxx111011xxxxxxxxxx
20044                                                                  fmlal.  */
20045                                                               return 2362;
20046                                                             }
20047                                                           else
20048                                                             {
20049                                                               /* 33222222222211111111110000000000
20050                                                                  10987654321098765432109876543210
20051                                                                  x10011100x1xxxxx111011xxxxxxxxxx
20052                                                                  fmlal.  */
20053                                                               return 2366;
20054                                                             }
20055                                                         }
20056                                                       else
20057                                                         {
20058                                                           /* 33222222222211111111110000000000
20059                                                              10987654321098765432109876543210
20060                                                              xx1011100x1xxxxx111011xxxxxxxxxx
20061                                                              facge.  */
20062                                                           return 350;
20063                                                         }
20064                                                     }
20065                                                   else
20066                                                     {
20067                                                       if (((word >> 29) & 0x1) == 0)
20068                                                         {
20069                                                           if (((word >> 30) & 0x1) == 0)
20070                                                             {
20071                                                               /* 33222222222211111111110000000000
20072                                                                  10987654321098765432109876543210
20073                                                                  x00011101x1xxxxx111011xxxxxxxxxx
20074                                                                  fmlsl.  */
20075                                                               return 2363;
20076                                                             }
20077                                                           else
20078                                                             {
20079                                                               /* 33222222222211111111110000000000
20080                                                                  10987654321098765432109876543210
20081                                                                  x10011101x1xxxxx111011xxxxxxxxxx
20082                                                                  fmlsl.  */
20083                                                               return 2367;
20084                                                             }
20085                                                         }
20086                                                       else
20087                                                         {
20088                                                           /* 33222222222211111111110000000000
20089                                                              10987654321098765432109876543210
20090                                                              xx1011101x1xxxxx111011xxxxxxxxxx
20091                                                              facgt.  */
20092                                                           return 364;
20093                                                         }
20094                                                     }
20095                                                 }
20096                                             }
20097                                         }
20098                                       else
20099                                         {
20100                                           if (((word >> 13) & 0x1) == 0)
20101                                             {
20102                                               if (((word >> 14) & 0x1) == 0)
20103                                                 {
20104                                                   if (((word >> 29) & 0x1) == 0)
20105                                                     {
20106                                                       /* 33222222222211111111110000000000
20107                                                          10987654321098765432109876543210
20108                                                          xx001110xx1xxxxx100111xxxxxxxxxx
20109                                                          mul.  */
20110                                                       return 286;
20111                                                     }
20112                                                   else
20113                                                     {
20114                                                       /* 33222222222211111111110000000000
20115                                                          10987654321098765432109876543210
20116                                                          xx101110xx1xxxxx100111xxxxxxxxxx
20117                                                          pmul.  */
20118                                                       return 338;
20119                                                     }
20120                                                 }
20121                                               else
20122                                                 {
20123                                                   if (((word >> 29) & 0x1) == 0)
20124                                                     {
20125                                                       /* 33222222222211111111110000000000
20126                                                          10987654321098765432109876543210
20127                                                          xx001110xx1xxxxx110111xxxxxxxxxx
20128                                                          fmulx.  */
20129                                                       return 297;
20130                                                     }
20131                                                   else
20132                                                     {
20133                                                       /* 33222222222211111111110000000000
20134                                                          10987654321098765432109876543210
20135                                                          xx101110xx1xxxxx110111xxxxxxxxxx
20136                                                          fmul.  */
20137                                                       return 346;
20138                                                     }
20139                                                 }
20140                                             }
20141                                           else
20142                                             {
20143                                               if (((word >> 14) & 0x1) == 0)
20144                                                 {
20145                                                   /* 33222222222211111111110000000000
20146                                                      10987654321098765432109876543210
20147                                                      xxx01110xx1xxxxx101111xxxxxxxxxx
20148                                                      addp.  */
20149                                                   return 290;
20150                                                 }
20151                                               else
20152                                                 {
20153                                                   if (((word >> 23) & 0x1) == 0)
20154                                                     {
20155                                                       if (((word >> 29) & 0x1) == 0)
20156                                                         {
20157                                                           /* 33222222222211111111110000000000
20158                                                              10987654321098765432109876543210
20159                                                              xx0011100x1xxxxx111111xxxxxxxxxx
20160                                                              frecps.  */
20161                                                           return 303;
20162                                                         }
20163                                                       else
20164                                                         {
20165                                                           /* 33222222222211111111110000000000
20166                                                              10987654321098765432109876543210
20167                                                              xx1011100x1xxxxx111111xxxxxxxxxx
20168                                                              fdiv.  */
20169                                                           return 354;
20170                                                         }
20171                                                     }
20172                                                   else
20173                                                     {
20174                                                       /* 33222222222211111111110000000000
20175                                                          10987654321098765432109876543210
20176                                                          xxx011101x1xxxxx111111xxxxxxxxxx
20177                                                          frsqrts.  */
20178                                                       return 315;
20179                                                     }
20180                                                 }
20181                                             }
20182                                         }
20183                                     }
20184                                 }
20185                             }
20186                         }
20187                       else
20188                         {
20189                           if (((word >> 10) & 0x1) == 0)
20190                             {
20191                               if (((word >> 11) & 0x1) == 0)
20192                                 {
20193                                   if (((word >> 12) & 0x1) == 0)
20194                                     {
20195                                       if (((word >> 13) & 0x1) == 0)
20196                                         {
20197                                           if (((word >> 14) & 0x1) == 0)
20198                                             {
20199                                               if (((word >> 16) & 0x1) == 0)
20200                                                 {
20201                                                   if (((word >> 17) & 0x1) == 0)
20202                                                     {
20203                                                       if (((word >> 18) & 0x1) == 0)
20204                                                         {
20205                                                           if (((word >> 19) & 0x1) == 0)
20206                                                             {
20207                                                               if (((word >> 20) & 0x1) == 0)
20208                                                                 {
20209                                                                   /* 33222222222211111111110000000000
20210                                                                      10987654321098765432109876543210
20211                                                                      xxx11110xx100000x00000xxxxxxxxxx
20212                                                                      fcvtns.  */
20213                                                                   return 768;
20214                                                                 }
20215                                                               else
20216                                                                 {
20217                                                                   /* 33222222222211111111110000000000
20218                                                                      10987654321098765432109876543210
20219                                                                      xxx11110xx110000x00000xxxxxxxxxx
20220                                                                      fcvtms.  */
20221                                                                   return 788;
20222                                                                 }
20223                                                             }
20224                                                           else
20225                                                             {
20226                                                               if (((word >> 20) & 0x1) == 0)
20227                                                                 {
20228                                                                   /* 33222222222211111111110000000000
20229                                                                      10987654321098765432109876543210
20230                                                                      xxx11110xx101000x00000xxxxxxxxxx
20231                                                                      fcvtps.  */
20232                                                                   return 784;
20233                                                                 }
20234                                                               else
20235                                                                 {
20236                                                                   /* 33222222222211111111110000000000
20237                                                                      10987654321098765432109876543210
20238                                                                      xxx11110xx111000x00000xxxxxxxxxx
20239                                                                      fcvtzs.  */
20240                                                                   return 792;
20241                                                                 }
20242                                                             }
20243                                                         }
20244                                                       else
20245                                                         {
20246                                                           /* 33222222222211111111110000000000
20247                                                              10987654321098765432109876543210
20248                                                              xxx11110xx1xx100x00000xxxxxxxxxx
20249                                                              fcvtas.  */
20250                                                           return 776;
20251                                                         }
20252                                                     }
20253                                                   else
20254                                                     {
20255                                                       if (((word >> 18) & 0x1) == 0)
20256                                                         {
20257                                                           /* 33222222222211111111110000000000
20258                                                              10987654321098765432109876543210
20259                                                              xxx11110xx1xx010x00000xxxxxxxxxx
20260                                                              scvtf.  */
20261                                                           return 772;
20262                                                         }
20263                                                       else
20264                                                         {
20265                                                           if (((word >> 19) & 0x1) == 0)
20266                                                             {
20267                                                               /* 33222222222211111111110000000000
20268                                                                  10987654321098765432109876543210
20269                                                                  xxx11110xx1x0110x00000xxxxxxxxxx
20270                                                                  fmov.  */
20271                                                               return 780;
20272                                                             }
20273                                                           else
20274                                                             {
20275                                                               if (((word >> 20) & 0x1) == 0)
20276                                                                 {
20277                                                                   /* 33222222222211111111110000000000
20278                                                                      10987654321098765432109876543210
20279                                                                      xxx11110xx101110x00000xxxxxxxxxx
20280                                                                      fmov.  */
20281                                                                   return 796;
20282                                                                 }
20283                                                               else
20284                                                                 {
20285                                                                   /* 33222222222211111111110000000000
20286                                                                      10987654321098765432109876543210
20287                                                                      xxx11110xx111110x00000xxxxxxxxxx
20288                                                                      fjcvtzs.  */
20289                                                                   return 798;
20290                                                                 }
20291                                                             }
20292                                                         }
20293                                                     }
20294                                                 }
20295                                               else
20296                                                 {
20297                                                   if (((word >> 17) & 0x1) == 0)
20298                                                     {
20299                                                       if (((word >> 18) & 0x1) == 0)
20300                                                         {
20301                                                           if (((word >> 19) & 0x1) == 0)
20302                                                             {
20303                                                               if (((word >> 20) & 0x1) == 0)
20304                                                                 {
20305                                                                   /* 33222222222211111111110000000000
20306                                                                      10987654321098765432109876543210
20307                                                                      xxx11110xx100001x00000xxxxxxxxxx
20308                                                                      fcvtnu.  */
20309                                                                   return 770;
20310                                                                 }
20311                                                               else
20312                                                                 {
20313                                                                   /* 33222222222211111111110000000000
20314                                                                      10987654321098765432109876543210
20315                                                                      xxx11110xx110001x00000xxxxxxxxxx
20316                                                                      fcvtmu.  */
20317                                                                   return 790;
20318                                                                 }
20319                                                             }
20320                                                           else
20321                                                             {
20322                                                               if (((word >> 20) & 0x1) == 0)
20323                                                                 {
20324                                                                   /* 33222222222211111111110000000000
20325                                                                      10987654321098765432109876543210
20326                                                                      xxx11110xx101001x00000xxxxxxxxxx
20327                                                                      fcvtpu.  */
20328                                                                   return 786;
20329                                                                 }
20330                                                               else
20331                                                                 {
20332                                                                   /* 33222222222211111111110000000000
20333                                                                      10987654321098765432109876543210
20334                                                                      xxx11110xx111001x00000xxxxxxxxxx
20335                                                                      fcvtzu.  */
20336                                                                   return 794;
20337                                                                 }
20338                                                             }
20339                                                         }
20340                                                       else
20341                                                         {
20342                                                           /* 33222222222211111111110000000000
20343                                                              10987654321098765432109876543210
20344                                                              xxx11110xx1xx101x00000xxxxxxxxxx
20345                                                              fcvtau.  */
20346                                                           return 778;
20347                                                         }
20348                                                     }
20349                                                   else
20350                                                     {
20351                                                       if (((word >> 18) & 0x1) == 0)
20352                                                         {
20353                                                           /* 33222222222211111111110000000000
20354                                                              10987654321098765432109876543210
20355                                                              xxx11110xx1xx011x00000xxxxxxxxxx
20356                                                              ucvtf.  */
20357                                                           return 774;
20358                                                         }
20359                                                       else
20360                                                         {
20361                                                           if (((word >> 19) & 0x1) == 0)
20362                                                             {
20363                                                               /* 33222222222211111111110000000000
20364                                                                  10987654321098765432109876543210
20365                                                                  xxx11110xx1x0111x00000xxxxxxxxxx
20366                                                                  fmov.  */
20367                                                               return 782;
20368                                                             }
20369                                                           else
20370                                                             {
20371                                                               /* 33222222222211111111110000000000
20372                                                                  10987654321098765432109876543210
20373                                                                  xxx11110xx1x1111x00000xxxxxxxxxx
20374                                                                  fmov.  */
20375                                                               return 797;
20376                                                             }
20377                                                         }
20378                                                     }
20379                                                 }
20380                                             }
20381                                           else
20382                                             {
20383                                               if (((word >> 17) & 0x1) == 0)
20384                                                 {
20385                                                   if (((word >> 15) & 0x1) == 0)
20386                                                     {
20387                                                       if (((word >> 16) & 0x1) == 0)
20388                                                         {
20389                                                           if (((word >> 18) & 0x1) == 0)
20390                                                             {
20391                                                               if (((word >> 19) & 0x1) == 0)
20392                                                                 {
20393                                                                   /* 33222222222211111111110000000000
20394                                                                      10987654321098765432109876543210
20395                                                                      xxx11110xx1x0000010000xxxxxxxxxx
20396                                                                      fmov.  */
20397                                                                   return 817;
20398                                                                 }
20399                                                               else
20400                                                                 {
20401                                                                   /* 33222222222211111111110000000000
20402                                                                      10987654321098765432109876543210
20403                                                                      xxx11110xx1x1000010000xxxxxxxxxx
20404                                                                      frint32z.  */
20405                                                                   return 813;
20406                                                                 }
20407                                                             }
20408                                                           else
20409                                                             {
20410                                                               /* 33222222222211111111110000000000
20411                                                                  10987654321098765432109876543210
20412                                                                  xxx11110xx1xx100010000xxxxxxxxxx
20413                                                                  frintn.  */
20414                                                               return 826;
20415                                                             }
20416                                                         }
20417                                                       else
20418                                                         {
20419                                                           if (((word >> 18) & 0x1) == 0)
20420                                                             {
20421                                                               if (((word >> 19) & 0x1) == 0)
20422                                                                 {
20423                                                                   /* 33222222222211111111110000000000
20424                                                                      10987654321098765432109876543210
20425                                                                      xxx11110xx1x0001010000xxxxxxxxxx
20426                                                                      fneg.  */
20427                                                                   return 821;
20428                                                                 }
20429                                                               else
20430                                                                 {
20431                                                                   /* 33222222222211111111110000000000
20432                                                                      10987654321098765432109876543210
20433                                                                      xxx11110xx1x1001010000xxxxxxxxxx
20434                                                                      frint64z.  */
20435                                                                   return 815;
20436                                                                 }
20437                                                             }
20438                                                           else
20439                                                             {
20440                                                               /* 33222222222211111111110000000000
20441                                                                  10987654321098765432109876543210
20442                                                                  xxx11110xx1xx101010000xxxxxxxxxx
20443                                                                  frintm.  */
20444                                                               return 830;
20445                                                             }
20446                                                         }
20447                                                     }
20448                                                   else
20449                                                     {
20450                                                       if (((word >> 16) & 0x1) == 0)
20451                                                         {
20452                                                           if (((word >> 18) & 0x1) == 0)
20453                                                             {
20454                                                               if (((word >> 19) & 0x1) == 0)
20455                                                                 {
20456                                                                   /* 33222222222211111111110000000000
20457                                                                      10987654321098765432109876543210
20458                                                                      xxx11110xx1x0000110000xxxxxxxxxx
20459                                                                      fabs.  */
20460                                                                   return 819;
20461                                                                 }
20462                                                               else
20463                                                                 {
20464                                                                   /* 33222222222211111111110000000000
20465                                                                      10987654321098765432109876543210
20466                                                                      xxx11110xx1x1000110000xxxxxxxxxx
20467                                                                      frint32x.  */
20468                                                                   return 814;
20469                                                                 }
20470                                                             }
20471                                                           else
20472                                                             {
20473                                                               /* 33222222222211111111110000000000
20474                                                                  10987654321098765432109876543210
20475                                                                  xxx11110xx1xx100110000xxxxxxxxxx
20476                                                                  frintp.  */
20477                                                               return 828;
20478                                                             }
20479                                                         }
20480                                                       else
20481                                                         {
20482                                                           if (((word >> 18) & 0x1) == 0)
20483                                                             {
20484                                                               if (((word >> 19) & 0x1) == 0)
20485                                                                 {
20486                                                                   /* 33222222222211111111110000000000
20487                                                                      10987654321098765432109876543210
20488                                                                      xxx11110xx1x0001110000xxxxxxxxxx
20489                                                                      fsqrt.  */
20490                                                                   return 823;
20491                                                                 }
20492                                                               else
20493                                                                 {
20494                                                                   /* 33222222222211111111110000000000
20495                                                                      10987654321098765432109876543210
20496                                                                      xxx11110xx1x1001110000xxxxxxxxxx
20497                                                                      frint64x.  */
20498                                                                   return 816;
20499                                                                 }
20500                                                             }
20501                                                           else
20502                                                             {
20503                                                               /* 33222222222211111111110000000000
20504                                                                  10987654321098765432109876543210
20505                                                                  xxx11110xx1xx101110000xxxxxxxxxx
20506                                                                  frintz.  */
20507                                                               return 832;
20508                                                             }
20509                                                         }
20510                                                     }
20511                                                 }
20512                                               else
20513                                                 {
20514                                                   if (((word >> 18) & 0x1) == 0)
20515                                                     {
20516                                                       /* 33222222222211111111110000000000
20517                                                          10987654321098765432109876543210
20518                                                          xxx11110xx1xx01xx10000xxxxxxxxxx
20519                                                          fcvt.  */
20520                                                       return 825;
20521                                                     }
20522                                                   else
20523                                                     {
20524                                                       if (((word >> 15) & 0x1) == 0)
20525                                                         {
20526                                                           if (((word >> 16) & 0x1) == 0)
20527                                                             {
20528                                                               /* 33222222222211111111110000000000
20529                                                                  10987654321098765432109876543210
20530                                                                  xxx11110xx1xx110010000xxxxxxxxxx
20531                                                                  frinta.  */
20532                                                               return 834;
20533                                                             }
20534                                                           else
20535                                                             {
20536                                                               /* 33222222222211111111110000000000
20537                                                                  10987654321098765432109876543210
20538                                                                  xxx11110xx1xx111010000xxxxxxxxxx
20539                                                                  frintx.  */
20540                                                               return 836;
20541                                                             }
20542                                                         }
20543                                                       else
20544                                                         {
20545                                                           /* 33222222222211111111110000000000
20546                                                              10987654321098765432109876543210
20547                                                              xxx11110xx1xx11x110000xxxxxxxxxx
20548                                                              frinti.  */
20549                                                           return 838;
20550                                                         }
20551                                                     }
20552                                                 }
20553                                             }
20554                                         }
20555                                       else
20556                                         {
20557                                           if (((word >> 3) & 0x1) == 0)
20558                                             {
20559                                               if (((word >> 4) & 0x1) == 0)
20560                                                 {
20561                                                   /* 33222222222211111111110000000000
20562                                                      10987654321098765432109876543210
20563                                                      xxx11110xx1xxxxxxx1000xxxxx00xxx
20564                                                      fcmp.  */
20565                                                   return 803;
20566                                                 }
20567                                               else
20568                                                 {
20569                                                   /* 33222222222211111111110000000000
20570                                                      10987654321098765432109876543210
20571                                                      xxx11110xx1xxxxxxx1000xxxxx10xxx
20572                                                      fcmpe.  */
20573                                                   return 805;
20574                                                 }
20575                                             }
20576                                           else
20577                                             {
20578                                               if (((word >> 4) & 0x1) == 0)
20579                                                 {
20580                                                   /* 33222222222211111111110000000000
20581                                                      10987654321098765432109876543210
20582                                                      xxx11110xx1xxxxxxx1000xxxxx01xxx
20583                                                      fcmp.  */
20584                                                   return 807;
20585                                                 }
20586                                               else
20587                                                 {
20588                                                   /* 33222222222211111111110000000000
20589                                                      10987654321098765432109876543210
20590                                                      xxx11110xx1xxxxxxx1000xxxxx11xxx
20591                                                      fcmpe.  */
20592                                                   return 809;
20593                                                 }
20594                                             }
20595                                         }
20596                                     }
20597                                   else
20598                                     {
20599                                       if (((word >> 30) & 0x1) == 0)
20600                                         {
20601                                           /* 33222222222211111111110000000000
20602                                              10987654321098765432109876543210
20603                                              x0x11110xx1xxxxxxxx100xxxxxxxxxx
20604                                              fmov.  */
20605                                           return 866;
20606                                         }
20607                                       else
20608                                         {
20609                                           if (((word >> 13) & 0x1) == 0)
20610                                             {
20611                                               if (((word >> 14) & 0x1) == 0)
20612                                                 {
20613                                                   /* 33222222222211111111110000000000
20614                                                      10987654321098765432109876543210
20615                                                      x1x11110xx1xxxxxx00100xxxxxxxxxx
20616                                                      sqdmlal.  */
20617                                                   return 422;
20618                                                 }
20619                                               else
20620                                                 {
20621                                                   /* 33222222222211111111110000000000
20622                                                      10987654321098765432109876543210
20623                                                      x1x11110xx1xxxxxx10100xxxxxxxxxx
20624                                                      sqdmull.  */
20625                                                   return 424;
20626                                                 }
20627                                             }
20628                                           else
20629                                             {
20630                                               /* 33222222222211111111110000000000
20631                                                  10987654321098765432109876543210
20632                                                  x1x11110xx1xxxxxxx1100xxxxxxxxxx
20633                                                  sqdmlsl.  */
20634                                               return 423;
20635                                             }
20636                                         }
20637                                     }
20638                                 }
20639                               else
20640                                 {
20641                                   if (((word >> 12) & 0x1) == 0)
20642                                     {
20643                                       if (((word >> 13) & 0x1) == 0)
20644                                         {
20645                                           if (((word >> 14) & 0x1) == 0)
20646                                             {
20647                                               if (((word >> 15) & 0x1) == 0)
20648                                                 {
20649                                                   if (((word >> 30) & 0x1) == 0)
20650                                                     {
20651                                                       /* 33222222222211111111110000000000
20652                                                          10987654321098765432109876543210
20653                                                          x0x11110xx1xxxxx000010xxxxxxxxxx
20654                                                          fmul.  */
20655                                                       return 840;
20656                                                     }
20657                                                   else
20658                                                     {
20659                                                       /* 33222222222211111111110000000000
20660                                                          10987654321098765432109876543210
20661                                                          x1x11110xx1xxxxx000010xxxxxxxxxx
20662                                                          sha1h.  */
20663                                                       return 675;
20664                                                     }
20665                                                 }
20666                                               else
20667                                                 {
20668                                                   if (((word >> 29) & 0x1) == 0)
20669                                                     {
20670                                                       if (((word >> 30) & 0x1) == 0)
20671                                                         {
20672                                                           /* 33222222222211111111110000000000
20673                                                              10987654321098765432109876543210
20674                                                              x0011110xx1xxxxx100010xxxxxxxxxx
20675                                                              fnmul.  */
20676                                                           return 856;
20677                                                         }
20678                                                       else
20679                                                         {
20680                                                           /* 33222222222211111111110000000000
20681                                                              10987654321098765432109876543210
20682                                                              x1011110xx1xxxxx100010xxxxxxxxxx
20683                                                              cmgt.  */
20684                                                           return 482;
20685                                                         }
20686                                                     }
20687                                                   else
20688                                                     {
20689                                                       /* 33222222222211111111110000000000
20690                                                          10987654321098765432109876543210
20691                                                          xx111110xx1xxxxx100010xxxxxxxxxx
20692                                                          cmge.  */
20693                                                       return 511;
20694                                                     }
20695                                                 }
20696                                             }
20697                                           else
20698                                             {
20699                                               if (((word >> 15) & 0x1) == 0)
20700                                                 {
20701                                                   if (((word >> 29) & 0x1) == 0)
20702                                                     {
20703                                                       if (((word >> 30) & 0x1) == 0)
20704                                                         {
20705                                                           /* 33222222222211111111110000000000
20706                                                              10987654321098765432109876543210
20707                                                              x0011110xx1xxxxx010010xxxxxxxxxx
20708                                                              fmax.  */
20709                                                           return 848;
20710                                                         }
20711                                                       else
20712                                                         {
20713                                                           /* 33222222222211111111110000000000
20714                                                              10987654321098765432109876543210
20715                                                              x1011110xx1xxxxx010010xxxxxxxxxx
20716                                                              sqxtn.  */
20717                                                           return 486;
20718                                                         }
20719                                                     }
20720                                                   else
20721                                                     {
20722                                                       /* 33222222222211111111110000000000
20723                                                          10987654321098765432109876543210
20724                                                          xx111110xx1xxxxx010010xxxxxxxxxx
20725                                                          uqxtn.  */
20726                                                       return 515;
20727                                                     }
20728                                                 }
20729                                               else
20730                                                 {
20731                                                   if (((word >> 16) & 0x1) == 0)
20732                                                     {
20733                                                       if (((word >> 19) & 0x1) == 0)
20734                                                         {
20735                                                           if (((word >> 20) & 0x1) == 0)
20736                                                             {
20737                                                               if (((word >> 29) & 0x1) == 0)
20738                                                                 {
20739                                                                   /* 33222222222211111111110000000000
20740                                                                      10987654321098765432109876543210
20741                                                                      xx011110xx100xx0110010xxxxxxxxxx
20742                                                                      fcmgt.  */
20743                                                                   return 495;
20744                                                                 }
20745                                                               else
20746                                                                 {
20747                                                                   /* 33222222222211111111110000000000
20748                                                                      10987654321098765432109876543210
20749                                                                      xx111110xx100xx0110010xxxxxxxxxx
20750                                                                      fcmge.  */
20751                                                                   return 525;
20752                                                                 }
20753                                                             }
20754                                                           else
20755                                                             {
20756                                                               if (((word >> 23) & 0x1) == 0)
20757                                                                 {
20758                                                                   if (((word >> 29) & 0x1) == 0)
20759                                                                     {
20760                                                                       /* 33222222222211111111110000000000
20761                                                                          10987654321098765432109876543210
20762                                                                          xx0111100x110xx0110010xxxxxxxxxx
20763                                                                          fmaxnmp.  */
20764                                                                       return 539;
20765                                                                     }
20766                                                                   else
20767                                                                     {
20768                                                                       /* 33222222222211111111110000000000
20769                                                                          10987654321098765432109876543210
20770                                                                          xx1111100x110xx0110010xxxxxxxxxx
20771                                                                          fmaxnmp.  */
20772                                                                       return 538;
20773                                                                     }
20774                                                                 }
20775                                                               else
20776                                                                 {
20777                                                                   if (((word >> 29) & 0x1) == 0)
20778                                                                     {
20779                                                                       /* 33222222222211111111110000000000
20780                                                                          10987654321098765432109876543210
20781                                                                          xx0111101x110xx0110010xxxxxxxxxx
20782                                                                          fminnmp.  */
20783                                                                       return 545;
20784                                                                     }
20785                                                                   else
20786                                                                     {
20787                                                                       /* 33222222222211111111110000000000
20788                                                                          10987654321098765432109876543210
20789                                                                          xx1111101x110xx0110010xxxxxxxxxx
20790                                                                          fminnmp.  */
20791                                                                       return 544;
20792                                                                     }
20793                                                                 }
20794                                                             }
20795                                                         }
20796                                                       else
20797                                                         {
20798                                                           if (((word >> 29) & 0x1) == 0)
20799                                                             {
20800                                                               /* 33222222222211111111110000000000
20801                                                                  10987654321098765432109876543210
20802                                                                  xx011110xx1x1xx0110010xxxxxxxxxx
20803                                                                  fcmgt.  */
20804                                                               return 496;
20805                                                             }
20806                                                           else
20807                                                             {
20808                                                               /* 33222222222211111111110000000000
20809                                                                  10987654321098765432109876543210
20810                                                                  xx111110xx1x1xx0110010xxxxxxxxxx
20811                                                                  fcmge.  */
20812                                                               return 526;
20813                                                             }
20814                                                         }
20815                                                     }
20816                                                   else
20817                                                     {
20818                                                       if (((word >> 19) & 0x1) == 0)
20819                                                         {
20820                                                           if (((word >> 29) & 0x1) == 0)
20821                                                             {
20822                                                               /* 33222222222211111111110000000000
20823                                                                  10987654321098765432109876543210
20824                                                                  xx011110xx1x0xx1110010xxxxxxxxxx
20825                                                                  fcvtas.  */
20826                                                               return 491;
20827                                                             }
20828                                                           else
20829                                                             {
20830                                                               /* 33222222222211111111110000000000
20831                                                                  10987654321098765432109876543210
20832                                                                  xx111110xx1x0xx1110010xxxxxxxxxx
20833                                                                  fcvtau.  */
20834                                                               return 521;
20835                                                             }
20836                                                         }
20837                                                       else
20838                                                         {
20839                                                           if (((word >> 29) & 0x1) == 0)
20840                                                             {
20841                                                               /* 33222222222211111111110000000000
20842                                                                  10987654321098765432109876543210
20843                                                                  xx011110xx1x1xx1110010xxxxxxxxxx
20844                                                                  fcvtas.  */
20845                                                               return 492;
20846                                                             }
20847                                                           else
20848                                                             {
20849                                                               /* 33222222222211111111110000000000
20850                                                                  10987654321098765432109876543210
20851                                                                  xx111110xx1x1xx1110010xxxxxxxxxx
20852                                                                  fcvtau.  */
20853                                                               return 522;
20854                                                             }
20855                                                         }
20856                                                     }
20857                                                 }
20858                                             }
20859                                         }
20860                                       else
20861                                         {
20862                                           if (((word >> 14) & 0x1) == 0)
20863                                             {
20864                                               if (((word >> 15) & 0x1) == 0)
20865                                                 {
20866                                                   if (((word >> 29) & 0x1) == 0)
20867                                                     {
20868                                                       if (((word >> 30) & 0x1) == 0)
20869                                                         {
20870                                                           /* 33222222222211111111110000000000
20871                                                              10987654321098765432109876543210
20872                                                              x0011110xx1xxxxx001010xxxxxxxxxx
20873                                                              fadd.  */
20874                                                           return 844;
20875                                                         }
20876                                                       else
20877                                                         {
20878                                                           /* 33222222222211111111110000000000
20879                                                              10987654321098765432109876543210
20880                                                              x1011110xx1xxxxx001010xxxxxxxxxx
20881                                                              sha256su0.  */
20882                                                           return 677;
20883                                                         }
20884                                                     }
20885                                                   else
20886                                                     {
20887                                                       /* 33222222222211111111110000000000
20888                                                          10987654321098765432109876543210
20889                                                          xx111110xx1xxxxx001010xxxxxxxxxx
20890                                                          sqxtun.  */
20891                                                       return 514;
20892                                                     }
20893                                                 }
20894                                               else
20895                                                 {
20896                                                   if (((word >> 16) & 0x1) == 0)
20897                                                     {
20898                                                       /* 33222222222211111111110000000000
20899                                                          10987654321098765432109876543210
20900                                                          xxx11110xx1xxxx0101010xxxxxxxxxx
20901                                                          cmlt.  */
20902                                                       return 484;
20903                                                     }
20904                                                   else
20905                                                     {
20906                                                       if (((word >> 19) & 0x1) == 0)
20907                                                         {
20908                                                           if (((word >> 23) & 0x1) == 0)
20909                                                             {
20910                                                               if (((word >> 29) & 0x1) == 0)
20911                                                                 {
20912                                                                   /* 33222222222211111111110000000000
20913                                                                      10987654321098765432109876543210
20914                                                                      xx0111100x1x0xx1101010xxxxxxxxxx
20915                                                                      fcvtns.  */
20916                                                                   return 487;
20917                                                                 }
20918                                                               else
20919                                                                 {
20920                                                                   /* 33222222222211111111110000000000
20921                                                                      10987654321098765432109876543210
20922                                                                      xx1111100x1x0xx1101010xxxxxxxxxx
20923                                                                      fcvtnu.  */
20924                                                                   return 517;
20925                                                                 }
20926                                                             }
20927                                                           else
20928                                                             {
20929                                                               if (((word >> 29) & 0x1) == 0)
20930                                                                 {
20931                                                                   /* 33222222222211111111110000000000
20932                                                                      10987654321098765432109876543210
20933                                                                      xx0111101x1x0xx1101010xxxxxxxxxx
20934                                                                      fcvtps.  */
20935                                                                   return 501;
20936                                                                 }
20937                                                               else
20938                                                                 {
20939                                                                   /* 33222222222211111111110000000000
20940                                                                      10987654321098765432109876543210
20941                                                                      xx1111101x1x0xx1101010xxxxxxxxxx
20942                                                                      fcvtpu.  */
20943                                                                   return 529;
20944                                                                 }
20945                                                             }
20946                                                         }
20947                                                       else
20948                                                         {
20949                                                           if (((word >> 23) & 0x1) == 0)
20950                                                             {
20951                                                               if (((word >> 29) & 0x1) == 0)
20952                                                                 {
20953                                                                   /* 33222222222211111111110000000000
20954                                                                      10987654321098765432109876543210
20955                                                                      xx0111100x1x1xx1101010xxxxxxxxxx
20956                                                                      fcvtns.  */
20957                                                                   return 488;
20958                                                                 }
20959                                                               else
20960                                                                 {
20961                                                                   /* 33222222222211111111110000000000
20962                                                                      10987654321098765432109876543210
20963                                                                      xx1111100x1x1xx1101010xxxxxxxxxx
20964                                                                      fcvtnu.  */
20965                                                                   return 518;
20966                                                                 }
20967                                                             }
20968                                                           else
20969                                                             {
20970                                                               if (((word >> 29) & 0x1) == 0)
20971                                                                 {
20972                                                                   /* 33222222222211111111110000000000
20973                                                                      10987654321098765432109876543210
20974                                                                      xx0111101x1x1xx1101010xxxxxxxxxx
20975                                                                      fcvtps.  */
20976                                                                   return 502;
20977                                                                 }
20978                                                               else
20979                                                                 {
20980                                                                   /* 33222222222211111111110000000000
20981                                                                      10987654321098765432109876543210
20982                                                                      xx1111101x1x1xx1101010xxxxxxxxxx
20983                                                                      fcvtpu.  */
20984                                                                   return 530;
20985                                                                 }
20986                                                             }
20987                                                         }
20988                                                     }
20989                                                 }
20990                                             }
20991                                           else
20992                                             {
20993                                               if (((word >> 15) & 0x1) == 0)
20994                                                 {
20995                                                   if (((word >> 29) & 0x1) == 0)
20996                                                     {
20997                                                       /* 33222222222211111111110000000000
20998                                                          10987654321098765432109876543210
20999                                                          xx011110xx1xxxxx011010xxxxxxxxxx
21000                                                          fmaxnm.  */
21001                                                       return 852;
21002                                                     }
21003                                                   else
21004                                                     {
21005                                                       /* 33222222222211111111110000000000
21006                                                          10987654321098765432109876543210
21007                                                          xx111110xx1xxxxx011010xxxxxxxxxx
21008                                                          fcvtxn.  */
21009                                                       return 516;
21010                                                     }
21011                                                 }
21012                                               else
21013                                                 {
21014                                                   if (((word >> 19) & 0x1) == 0)
21015                                                     {
21016                                                       /* 33222222222211111111110000000000
21017                                                          10987654321098765432109876543210
21018                                                          xxx11110xx1x0xxx111010xxxxxxxxxx
21019                                                          fcmlt.  */
21020                                                       return 499;
21021                                                     }
21022                                                   else
21023                                                     {
21024                                                       /* 33222222222211111111110000000000
21025                                                          10987654321098765432109876543210
21026                                                          xxx11110xx1x1xxx111010xxxxxxxxxx
21027                                                          fcmlt.  */
21028                                                       return 500;
21029                                                     }
21030                                                 }
21031                                             }
21032                                         }
21033                                     }
21034                                   else
21035                                     {
21036                                       if (((word >> 13) & 0x1) == 0)
21037                                         {
21038                                           if (((word >> 14) & 0x1) == 0)
21039                                             {
21040                                               if (((word >> 15) & 0x1) == 0)
21041                                                 {
21042                                                   if (((word >> 30) & 0x1) == 0)
21043                                                     {
21044                                                       /* 33222222222211111111110000000000
21045                                                          10987654321098765432109876543210
21046                                                          x0x11110xx1xxxxx000110xxxxxxxxxx
21047                                                          fdiv.  */
21048                                                       return 842;
21049                                                     }
21050                                                   else
21051                                                     {
21052                                                       /* 33222222222211111111110000000000
21053                                                          10987654321098765432109876543210
21054                                                          x1x11110xx1xxxxx000110xxxxxxxxxx
21055                                                          sha1su1.  */
21056                                                       return 676;
21057                                                     }
21058                                                 }
21059                                               else
21060                                                 {
21061                                                   if (((word >> 29) & 0x1) == 0)
21062                                                     {
21063                                                       /* 33222222222211111111110000000000
21064                                                          10987654321098765432109876543210
21065                                                          xx011110xx1xxxxx100110xxxxxxxxxx
21066                                                          cmeq.  */
21067                                                       return 483;
21068                                                     }
21069                                                   else
21070                                                     {
21071                                                       /* 33222222222211111111110000000000
21072                                                          10987654321098765432109876543210
21073                                                          xx111110xx1xxxxx100110xxxxxxxxxx
21074                                                          cmle.  */
21075                                                       return 512;
21076                                                     }
21077                                                 }
21078                                             }
21079                                           else
21080                                             {
21081                                               if (((word >> 15) & 0x1) == 0)
21082                                                 {
21083                                                   /* 33222222222211111111110000000000
21084                                                      10987654321098765432109876543210
21085                                                      xxx11110xx1xxxxx010110xxxxxxxxxx
21086                                                      fmin.  */
21087                                                   return 850;
21088                                                 }
21089                                               else
21090                                                 {
21091                                                   if (((word >> 16) & 0x1) == 0)
21092                                                     {
21093                                                       if (((word >> 19) & 0x1) == 0)
21094                                                         {
21095                                                           if (((word >> 20) & 0x1) == 0)
21096                                                             {
21097                                                               if (((word >> 29) & 0x1) == 0)
21098                                                                 {
21099                                                                   /* 33222222222211111111110000000000
21100                                                                      10987654321098765432109876543210
21101                                                                      xx011110xx100xx0110110xxxxxxxxxx
21102                                                                      fcmeq.  */
21103                                                                   return 497;
21104                                                                 }
21105                                                               else
21106                                                                 {
21107                                                                   /* 33222222222211111111110000000000
21108                                                                      10987654321098765432109876543210
21109                                                                      xx111110xx100xx0110110xxxxxxxxxx
21110                                                                      fcmle.  */
21111                                                                   return 527;
21112                                                                 }
21113                                                             }
21114                                                           else
21115                                                             {
21116                                                               if (((word >> 29) & 0x1) == 0)
21117                                                                 {
21118                                                                   /* 33222222222211111111110000000000
21119                                                                      10987654321098765432109876543210
21120                                                                      xx011110xx110xx0110110xxxxxxxxxx
21121                                                                      faddp.  */
21122                                                                   return 541;
21123                                                                 }
21124                                                               else
21125                                                                 {
21126                                                                   /* 33222222222211111111110000000000
21127                                                                      10987654321098765432109876543210
21128                                                                      xx111110xx110xx0110110xxxxxxxxxx
21129                                                                      faddp.  */
21130                                                                   return 540;
21131                                                                 }
21132                                                             }
21133                                                         }
21134                                                       else
21135                                                         {
21136                                                           if (((word >> 29) & 0x1) == 0)
21137                                                             {
21138                                                               /* 33222222222211111111110000000000
21139                                                                  10987654321098765432109876543210
21140                                                                  xx011110xx1x1xx0110110xxxxxxxxxx
21141                                                                  fcmeq.  */
21142                                                               return 498;
21143                                                             }
21144                                                           else
21145                                                             {
21146                                                               /* 33222222222211111111110000000000
21147                                                                  10987654321098765432109876543210
21148                                                                  xx111110xx1x1xx0110110xxxxxxxxxx
21149                                                                  fcmle.  */
21150                                                               return 528;
21151                                                             }
21152                                                         }
21153                                                     }
21154                                                   else
21155                                                     {
21156                                                       if (((word >> 19) & 0x1) == 0)
21157                                                         {
21158                                                           if (((word >> 23) & 0x1) == 0)
21159                                                             {
21160                                                               if (((word >> 29) & 0x1) == 0)
21161                                                                 {
21162                                                                   /* 33222222222211111111110000000000
21163                                                                      10987654321098765432109876543210
21164                                                                      xx0111100x1x0xx1110110xxxxxxxxxx
21165                                                                      scvtf.  */
21166                                                                   return 493;
21167                                                                 }
21168                                                               else
21169                                                                 {
21170                                                                   /* 33222222222211111111110000000000
21171                                                                      10987654321098765432109876543210
21172                                                                      xx1111100x1x0xx1110110xxxxxxxxxx
21173                                                                      ucvtf.  */
21174                                                                   return 523;
21175                                                                 }
21176                                                             }
21177                                                           else
21178                                                             {
21179                                                               if (((word >> 29) & 0x1) == 0)
21180                                                                 {
21181                                                                   /* 33222222222211111111110000000000
21182                                                                      10987654321098765432109876543210
21183                                                                      xx0111101x1x0xx1110110xxxxxxxxxx
21184                                                                      frecpe.  */
21185                                                                   return 505;
21186                                                                 }
21187                                                               else
21188                                                                 {
21189                                                                   /* 33222222222211111111110000000000
21190                                                                      10987654321098765432109876543210
21191                                                                      xx1111101x1x0xx1110110xxxxxxxxxx
21192                                                                      frsqrte.  */
21193                                                                   return 533;
21194                                                                 }
21195                                                             }
21196                                                         }
21197                                                       else
21198                                                         {
21199                                                           if (((word >> 23) & 0x1) == 0)
21200                                                             {
21201                                                               if (((word >> 29) & 0x1) == 0)
21202                                                                 {
21203                                                                   /* 33222222222211111111110000000000
21204                                                                      10987654321098765432109876543210
21205                                                                      xx0111100x1x1xx1110110xxxxxxxxxx
21206                                                                      scvtf.  */
21207                                                                   return 494;
21208                                                                 }
21209                                                               else
21210                                                                 {
21211                                                                   /* 33222222222211111111110000000000
21212                                                                      10987654321098765432109876543210
21213                                                                      xx1111100x1x1xx1110110xxxxxxxxxx
21214                                                                      ucvtf.  */
21215                                                                   return 524;
21216                                                                 }
21217                                                             }
21218                                                           else
21219                                                             {
21220                                                               if (((word >> 29) & 0x1) == 0)
21221                                                                 {
21222                                                                   /* 33222222222211111111110000000000
21223                                                                      10987654321098765432109876543210
21224                                                                      xx0111101x1x1xx1110110xxxxxxxxxx
21225                                                                      frecpe.  */
21226                                                                   return 506;
21227                                                                 }
21228                                                               else
21229                                                                 {
21230                                                                   /* 33222222222211111111110000000000
21231                                                                      10987654321098765432109876543210
21232                                                                      xx1111101x1x1xx1110110xxxxxxxxxx
21233                                                                      frsqrte.  */
21234                                                                   return 534;
21235                                                                 }
21236                                                             }
21237                                                         }
21238                                                     }
21239                                                 }
21240                                             }
21241                                         }
21242                                       else
21243                                         {
21244                                           if (((word >> 14) & 0x1) == 0)
21245                                             {
21246                                               if (((word >> 15) & 0x1) == 0)
21247                                                 {
21248                                                   if (((word >> 29) & 0x1) == 0)
21249                                                     {
21250                                                       if (((word >> 30) & 0x1) == 0)
21251                                                         {
21252                                                           /* 33222222222211111111110000000000
21253                                                              10987654321098765432109876543210
21254                                                              x0011110xx1xxxxx001110xxxxxxxxxx
21255                                                              fsub.  */
21256                                                           return 846;
21257                                                         }
21258                                                       else
21259                                                         {
21260                                                           /* 33222222222211111111110000000000
21261                                                              10987654321098765432109876543210
21262                                                              x1011110xx1xxxxx001110xxxxxxxxxx
21263                                                              suqadd.  */
21264                                                           return 480;
21265                                                         }
21266                                                     }
21267                                                   else
21268                                                     {
21269                                                       /* 33222222222211111111110000000000
21270                                                          10987654321098765432109876543210
21271                                                          xx111110xx1xxxxx001110xxxxxxxxxx
21272                                                          usqadd.  */
21273                                                       return 509;
21274                                                     }
21275                                                 }
21276                                               else
21277                                                 {
21278                                                   if (((word >> 16) & 0x1) == 0)
21279                                                     {
21280                                                       if (((word >> 29) & 0x1) == 0)
21281                                                         {
21282                                                           /* 33222222222211111111110000000000
21283                                                              10987654321098765432109876543210
21284                                                              xx011110xx1xxxx0101110xxxxxxxxxx
21285                                                              abs.  */
21286                                                           return 485;
21287                                                         }
21288                                                       else
21289                                                         {
21290                                                           /* 33222222222211111111110000000000
21291                                                              10987654321098765432109876543210
21292                                                              xx111110xx1xxxx0101110xxxxxxxxxx
21293                                                              neg.  */
21294                                                           return 513;
21295                                                         }
21296                                                     }
21297                                                   else
21298                                                     {
21299                                                       if (((word >> 19) & 0x1) == 0)
21300                                                         {
21301                                                           if (((word >> 20) & 0x1) == 0)
21302                                                             {
21303                                                               if (((word >> 23) & 0x1) == 0)
21304                                                                 {
21305                                                                   if (((word >> 29) & 0x1) == 0)
21306                                                                     {
21307                                                                       /* 33222222222211111111110000000000
21308                                                                          10987654321098765432109876543210
21309                                                                          xx0111100x100xx1101110xxxxxxxxxx
21310                                                                          fcvtms.  */
21311                                                                       return 489;
21312                                                                     }
21313                                                                   else
21314                                                                     {
21315                                                                       /* 33222222222211111111110000000000
21316                                                                          10987654321098765432109876543210
21317                                                                          xx1111100x100xx1101110xxxxxxxxxx
21318                                                                          fcvtmu.  */
21319                                                                       return 519;
21320                                                                     }
21321                                                                 }
21322                                                               else
21323                                                                 {
21324                                                                   if (((word >> 29) & 0x1) == 0)
21325                                                                     {
21326                                                                       /* 33222222222211111111110000000000
21327                                                                          10987654321098765432109876543210
21328                                                                          xx0111101x100xx1101110xxxxxxxxxx
21329                                                                          fcvtzs.  */
21330                                                                       return 503;
21331                                                                     }
21332                                                                   else
21333                                                                     {
21334                                                                       /* 33222222222211111111110000000000
21335                                                                          10987654321098765432109876543210
21336                                                                          xx1111101x100xx1101110xxxxxxxxxx
21337                                                                          fcvtzu.  */
21338                                                                       return 531;
21339                                                                     }
21340                                                                 }
21341                                                             }
21342                                                           else
21343                                                             {
21344                                                               /* 33222222222211111111110000000000
21345                                                                  10987654321098765432109876543210
21346                                                                  xxx11110xx110xx1101110xxxxxxxxxx
21347                                                                  addp.  */
21348                                                               return 537;
21349                                                             }
21350                                                         }
21351                                                       else
21352                                                         {
21353                                                           if (((word >> 23) & 0x1) == 0)
21354                                                             {
21355                                                               if (((word >> 29) & 0x1) == 0)
21356                                                                 {
21357                                                                   /* 33222222222211111111110000000000
21358                                                                      10987654321098765432109876543210
21359                                                                      xx0111100x1x1xx1101110xxxxxxxxxx
21360                                                                      fcvtms.  */
21361                                                                   return 490;
21362                                                                 }
21363                                                               else
21364                                                                 {
21365                                                                   /* 33222222222211111111110000000000
21366                                                                      10987654321098765432109876543210
21367                                                                      xx1111100x1x1xx1101110xxxxxxxxxx
21368                                                                      fcvtmu.  */
21369                                                                   return 520;
21370                                                                 }
21371                                                             }
21372                                                           else
21373                                                             {
21374                                                               if (((word >> 29) & 0x1) == 0)
21375                                                                 {
21376                                                                   /* 33222222222211111111110000000000
21377                                                                      10987654321098765432109876543210
21378                                                                      xx0111101x1x1xx1101110xxxxxxxxxx
21379                                                                      fcvtzs.  */
21380                                                                   return 504;
21381                                                                 }
21382                                                               else
21383                                                                 {
21384                                                                   /* 33222222222211111111110000000000
21385                                                                      10987654321098765432109876543210
21386                                                                      xx1111101x1x1xx1101110xxxxxxxxxx
21387                                                                      fcvtzu.  */
21388                                                                   return 532;
21389                                                                 }
21390                                                             }
21391                                                         }
21392                                                     }
21393                                                 }
21394                                             }
21395                                           else
21396                                             {
21397                                               if (((word >> 15) & 0x1) == 0)
21398                                                 {
21399                                                   if (((word >> 29) & 0x1) == 0)
21400                                                     {
21401                                                       if (((word >> 30) & 0x1) == 0)
21402                                                         {
21403                                                           /* 33222222222211111111110000000000
21404                                                              10987654321098765432109876543210
21405                                                              x0011110xx1xxxxx011110xxxxxxxxxx
21406                                                              fminnm.  */
21407                                                           return 854;
21408                                                         }
21409                                                       else
21410                                                         {
21411                                                           /* 33222222222211111111110000000000
21412                                                              10987654321098765432109876543210
21413                                                              x1011110xx1xxxxx011110xxxxxxxxxx
21414                                                              sqabs.  */
21415                                                           return 481;
21416                                                         }
21417                                                     }
21418                                                   else
21419                                                     {
21420                                                       /* 33222222222211111111110000000000
21421                                                          10987654321098765432109876543210
21422                                                          xx111110xx1xxxxx011110xxxxxxxxxx
21423                                                          sqneg.  */
21424                                                       return 510;
21425                                                     }
21426                                                 }
21427                                               else
21428                                                 {
21429                                                   if (((word >> 16) & 0x1) == 0)
21430                                                     {
21431                                                       if (((word >> 23) & 0x1) == 0)
21432                                                         {
21433                                                           if (((word >> 29) & 0x1) == 0)
21434                                                             {
21435                                                               /* 33222222222211111111110000000000
21436                                                                  10987654321098765432109876543210
21437                                                                  xx0111100x1xxxx0111110xxxxxxxxxx
21438                                                                  fmaxp.  */
21439                                                               return 543;
21440                                                             }
21441                                                           else
21442                                                             {
21443                                                               /* 33222222222211111111110000000000
21444                                                                  10987654321098765432109876543210
21445                                                                  xx1111100x1xxxx0111110xxxxxxxxxx
21446                                                                  fmaxp.  */
21447                                                               return 542;
21448                                                             }
21449                                                         }
21450                                                       else
21451                                                         {
21452                                                           if (((word >> 29) & 0x1) == 0)
21453                                                             {
21454                                                               /* 33222222222211111111110000000000
21455                                                                  10987654321098765432109876543210
21456                                                                  xx0111101x1xxxx0111110xxxxxxxxxx
21457                                                                  fminp.  */
21458                                                               return 547;
21459                                                             }
21460                                                           else
21461                                                             {
21462                                                               /* 33222222222211111111110000000000
21463                                                                  10987654321098765432109876543210
21464                                                                  xx1111101x1xxxx0111110xxxxxxxxxx
21465                                                                  fminp.  */
21466                                                               return 546;
21467                                                             }
21468                                                         }
21469                                                     }
21470                                                   else
21471                                                     {
21472                                                       if (((word >> 19) & 0x1) == 0)
21473                                                         {
21474                                                           /* 33222222222211111111110000000000
21475                                                              10987654321098765432109876543210
21476                                                              xxx11110xx1x0xx1111110xxxxxxxxxx
21477                                                              frecpx.  */
21478                                                           return 507;
21479                                                         }
21480                                                       else
21481                                                         {
21482                                                           /* 33222222222211111111110000000000
21483                                                              10987654321098765432109876543210
21484                                                              xxx11110xx1x1xx1111110xxxxxxxxxx
21485                                                              frecpx.  */
21486                                                           return 508;
21487                                                         }
21488                                                     }
21489                                                 }
21490                                             }
21491                                         }
21492                                     }
21493                                 }
21494                             }
21495                           else
21496                             {
21497                               if (((word >> 11) & 0x1) == 0)
21498                                 {
21499                                   if (((word >> 29) & 0x1) == 0)
21500                                     {
21501                                       if (((word >> 30) & 0x1) == 0)
21502                                         {
21503                                           if (((word >> 4) & 0x1) == 0)
21504                                             {
21505                                               /* 33222222222211111111110000000000
21506                                                  10987654321098765432109876543210
21507                                                  x0011110xx1xxxxxxxxx01xxxxx0xxxx
21508                                                  fccmp.  */
21509                                               return 799;
21510                                             }
21511                                           else
21512                                             {
21513                                               /* 33222222222211111111110000000000
21514                                                  10987654321098765432109876543210
21515                                                  x0011110xx1xxxxxxxxx01xxxxx1xxxx
21516                                                  fccmpe.  */
21517                                               return 801;
21518                                             }
21519                                         }
21520                                       else
21521                                         {
21522                                           if (((word >> 12) & 0x1) == 0)
21523                                             {
21524                                               if (((word >> 13) & 0x1) == 0)
21525                                                 {
21526                                                   if (((word >> 14) & 0x1) == 0)
21527                                                     {
21528                                                       /* 33222222222211111111110000000000
21529                                                          10987654321098765432109876543210
21530                                                          x1011110xx1xxxxxx00001xxxxxxxxxx
21531                                                          add.  */
21532                                                       return 565;
21533                                                     }
21534                                                   else
21535                                                     {
21536                                                       /* 33222222222211111111110000000000
21537                                                          10987654321098765432109876543210
21538                                                          x1011110xx1xxxxxx10001xxxxxxxxxx
21539                                                          sshl.  */
21540                                                       return 563;
21541                                                     }
21542                                                 }
21543                                               else
21544                                                 {
21545                                                   /* 33222222222211111111110000000000
21546                                                      10987654321098765432109876543210
21547                                                      x1011110xx1xxxxxxx1001xxxxxxxxxx
21548                                                      fcmeq.  */
21549                                                   return 555;
21550                                                 }
21551                                             }
21552                                           else
21553                                             {
21554                                               if (((word >> 13) & 0x1) == 0)
21555                                                 {
21556                                                   /* 33222222222211111111110000000000
21557                                                      10987654321098765432109876543210
21558                                                      x1011110xx1xxxxxxx0101xxxxxxxxxx
21559                                                      srshl.  */
21560                                                   return 564;
21561                                                 }
21562                                               else
21563                                                 {
21564                                                   if (((word >> 15) & 0x1) == 0)
21565                                                     {
21566                                                       /* 33222222222211111111110000000000
21567                                                          10987654321098765432109876543210
21568                                                          x1011110xx1xxxxx0x1101xxxxxxxxxx
21569                                                          cmgt.  */
21570                                                       return 561;
21571                                                     }
21572                                                   else
21573                                                     {
21574                                                       /* 33222222222211111111110000000000
21575                                                          10987654321098765432109876543210
21576                                                          x1011110xx1xxxxx1x1101xxxxxxxxxx
21577                                                          sqdmulh.  */
21578                                                       return 552;
21579                                                     }
21580                                                 }
21581                                             }
21582                                         }
21583                                     }
21584                                   else
21585                                     {
21586                                       if (((word >> 12) & 0x1) == 0)
21587                                         {
21588                                           if (((word >> 13) & 0x1) == 0)
21589                                             {
21590                                               if (((word >> 14) & 0x1) == 0)
21591                                                 {
21592                                                   /* 33222222222211111111110000000000
21593                                                      10987654321098765432109876543210
21594                                                      xx111110xx1xxxxxx00001xxxxxxxxxx
21595                                                      sub.  */
21596                                                   return 586;
21597                                                 }
21598                                               else
21599                                                 {
21600                                                   /* 33222222222211111111110000000000
21601                                                      10987654321098765432109876543210
21602                                                      xx111110xx1xxxxxx10001xxxxxxxxxx
21603                                                      ushl.  */
21604                                                   return 584;
21605                                                 }
21606                                             }
21607                                           else
21608                                             {
21609                                               if (((word >> 23) & 0x1) == 0)
21610                                                 {
21611                                                   /* 33222222222211111111110000000000
21612                                                      10987654321098765432109876543210
21613                                                      xx1111100x1xxxxxxx1001xxxxxxxxxx
21614                                                      fcmge.  */
21615                                                   return 572;
21616                                                 }
21617                                               else
21618                                                 {
21619                                                   /* 33222222222211111111110000000000
21620                                                      10987654321098765432109876543210
21621                                                      xx1111101x1xxxxxxx1001xxxxxxxxxx
21622                                                      fcmgt.  */
21623                                                   return 578;
21624                                                 }
21625                                             }
21626                                         }
21627                                       else
21628                                         {
21629                                           if (((word >> 13) & 0x1) == 0)
21630                                             {
21631                                               if (((word >> 15) & 0x1) == 0)
21632                                                 {
21633                                                   /* 33222222222211111111110000000000
21634                                                      10987654321098765432109876543210
21635                                                      xx111110xx1xxxxx0x0101xxxxxxxxxx
21636                                                      urshl.  */
21637                                                   return 585;
21638                                                 }
21639                                               else
21640                                                 {
21641                                                   /* 33222222222211111111110000000000
21642                                                      10987654321098765432109876543210
21643                                                      xx111110xx1xxxxx1x0101xxxxxxxxxx
21644                                                      fabd.  */
21645                                                   return 576;
21646                                                 }
21647                                             }
21648                                           else
21649                                             {
21650                                               if (((word >> 15) & 0x1) == 0)
21651                                                 {
21652                                                   /* 33222222222211111111110000000000
21653                                                      10987654321098765432109876543210
21654                                                      xx111110xx1xxxxx0x1101xxxxxxxxxx
21655                                                      cmhi.  */
21656                                                   return 582;
21657                                                 }
21658                                               else
21659                                                 {
21660                                                   /* 33222222222211111111110000000000
21661                                                      10987654321098765432109876543210
21662                                                      xx111110xx1xxxxx1x1101xxxxxxxxxx
21663                                                      sqrdmulh.  */
21664                                                   return 571;
21665                                                 }
21666                                             }
21667                                         }
21668                                     }
21669                                 }
21670                               else
21671                                 {
21672                                   if (((word >> 29) & 0x1) == 0)
21673                                     {
21674                                       if (((word >> 30) & 0x1) == 0)
21675                                         {
21676                                           /* 33222222222211111111110000000000
21677                                              10987654321098765432109876543210
21678                                              x0011110xx1xxxxxxxxx11xxxxxxxxxx
21679                                              fcsel.  */
21680                                           return 868;
21681                                         }
21682                                       else
21683                                         {
21684                                           if (((word >> 12) & 0x1) == 0)
21685                                             {
21686                                               if (((word >> 13) & 0x1) == 0)
21687                                                 {
21688                                                   if (((word >> 14) & 0x1) == 0)
21689                                                     {
21690                                                       if (((word >> 15) & 0x1) == 0)
21691                                                         {
21692                                                           /* 33222222222211111111110000000000
21693                                                              10987654321098765432109876543210
21694                                                              x1011110xx1xxxxx000011xxxxxxxxxx
21695                                                              sqadd.  */
21696                                                           return 548;
21697                                                         }
21698                                                       else
21699                                                         {
21700                                                           /* 33222222222211111111110000000000
21701                                                              10987654321098765432109876543210
21702                                                              x1011110xx1xxxxx100011xxxxxxxxxx
21703                                                              cmtst.  */
21704                                                           return 566;
21705                                                         }
21706                                                     }
21707                                                   else
21708                                                     {
21709                                                       /* 33222222222211111111110000000000
21710                                                          10987654321098765432109876543210
21711                                                          x1011110xx1xxxxxx10011xxxxxxxxxx
21712                                                          sqshl.  */
21713                                                       return 550;
21714                                                     }
21715                                                 }
21716                                               else
21717                                                 {
21718                                                   /* 33222222222211111111110000000000
21719                                                      10987654321098765432109876543210
21720                                                      x1011110xx1xxxxxxx1011xxxxxxxxxx
21721                                                      sqsub.  */
21722                                                   return 549;
21723                                                 }
21724                                             }
21725                                           else
21726                                             {
21727                                               if (((word >> 13) & 0x1) == 0)
21728                                                 {
21729                                                   if (((word >> 15) & 0x1) == 0)
21730                                                     {
21731                                                       /* 33222222222211111111110000000000
21732                                                          10987654321098765432109876543210
21733                                                          x1011110xx1xxxxx0x0111xxxxxxxxxx
21734                                                          sqrshl.  */
21735                                                       return 551;
21736                                                     }
21737                                                   else
21738                                                     {
21739                                                       /* 33222222222211111111110000000000
21740                                                          10987654321098765432109876543210
21741                                                          x1011110xx1xxxxx1x0111xxxxxxxxxx
21742                                                          fmulx.  */
21743                                                       return 553;
21744                                                     }
21745                                                 }
21746                                               else
21747                                                 {
21748                                                   if (((word >> 14) & 0x1) == 0)
21749                                                     {
21750                                                       /* 33222222222211111111110000000000
21751                                                          10987654321098765432109876543210
21752                                                          x1011110xx1xxxxxx01111xxxxxxxxxx
21753                                                          cmge.  */
21754                                                       return 562;
21755                                                     }
21756                                                   else
21757                                                     {
21758                                                       if (((word >> 23) & 0x1) == 0)
21759                                                         {
21760                                                           /* 33222222222211111111110000000000
21761                                                              10987654321098765432109876543210
21762                                                              x10111100x1xxxxxx11111xxxxxxxxxx
21763                                                              frecps.  */
21764                                                           return 557;
21765                                                         }
21766                                                       else
21767                                                         {
21768                                                           /* 33222222222211111111110000000000
21769                                                              10987654321098765432109876543210
21770                                                              x10111101x1xxxxxx11111xxxxxxxxxx
21771                                                              frsqrts.  */
21772                                                           return 559;
21773                                                         }
21774                                                     }
21775                                                 }
21776                                             }
21777                                         }
21778                                     }
21779                                   else
21780                                     {
21781                                       if (((word >> 12) & 0x1) == 0)
21782                                         {
21783                                           if (((word >> 13) & 0x1) == 0)
21784                                             {
21785                                               if (((word >> 14) & 0x1) == 0)
21786                                                 {
21787                                                   if (((word >> 15) & 0x1) == 0)
21788                                                     {
21789                                                       /* 33222222222211111111110000000000
21790                                                          10987654321098765432109876543210
21791                                                          xx111110xx1xxxxx000011xxxxxxxxxx
21792                                                          uqadd.  */
21793                                                       return 567;
21794                                                     }
21795                                                   else
21796                                                     {
21797                                                       /* 33222222222211111111110000000000
21798                                                          10987654321098765432109876543210
21799                                                          xx111110xx1xxxxx100011xxxxxxxxxx
21800                                                          cmeq.  */
21801                                                       return 587;
21802                                                     }
21803                                                 }
21804                                               else
21805                                                 {
21806                                                   /* 33222222222211111111110000000000
21807                                                      10987654321098765432109876543210
21808                                                      xx111110xx1xxxxxx10011xxxxxxxxxx
21809                                                      uqshl.  */
21810                                                   return 569;
21811                                                 }
21812                                             }
21813                                           else
21814                                             {
21815                                               if (((word >> 14) & 0x1) == 0)
21816                                                 {
21817                                                   /* 33222222222211111111110000000000
21818                                                      10987654321098765432109876543210
21819                                                      xx111110xx1xxxxxx01011xxxxxxxxxx
21820                                                      uqsub.  */
21821                                                   return 568;
21822                                                 }
21823                                               else
21824                                                 {
21825                                                   if (((word >> 23) & 0x1) == 0)
21826                                                     {
21827                                                       /* 33222222222211111111110000000000
21828                                                          10987654321098765432109876543210
21829                                                          xx1111100x1xxxxxx11011xxxxxxxxxx
21830                                                          facge.  */
21831                                                       return 574;
21832                                                     }
21833                                                   else
21834                                                     {
21835                                                       /* 33222222222211111111110000000000
21836                                                          10987654321098765432109876543210
21837                                                          xx1111101x1xxxxxx11011xxxxxxxxxx
21838                                                          facgt.  */
21839                                                       return 580;
21840                                                     }
21841                                                 }
21842                                             }
21843                                         }
21844                                       else
21845                                         {
21846                                           if (((word >> 13) & 0x1) == 0)
21847                                             {
21848                                               /* 33222222222211111111110000000000
21849                                                  10987654321098765432109876543210
21850                                                  xx111110xx1xxxxxxx0111xxxxxxxxxx
21851                                                  uqrshl.  */
21852                                               return 570;
21853                                             }
21854                                           else
21855                                             {
21856                                               /* 33222222222211111111110000000000
21857                                                  10987654321098765432109876543210
21858                                                  xx111110xx1xxxxxxx1111xxxxxxxxxx
21859                                                  cmhs.  */
21860                                               return 583;
21861                                             }
21862                                         }
21863                                     }
21864                                 }
21865                             }
21866                         }
21867                     }
21868                 }
21869               else
21870                 {
21871                   if (((word >> 15) & 0x1) == 0)
21872                     {
21873                       if (((word >> 28) & 0x1) == 0)
21874                         {
21875                           if (((word >> 10) & 0x1) == 0)
21876                             {
21877                               if (((word >> 12) & 0x1) == 0)
21878                                 {
21879                                   if (((word >> 13) & 0x1) == 0)
21880                                     {
21881                                       if (((word >> 14) & 0x1) == 0)
21882                                         {
21883                                           if (((word >> 29) & 0x1) == 0)
21884                                             {
21885                                               if (((word >> 30) & 0x1) == 0)
21886                                                 {
21887                                                   /* 33222222222211111111110000000000
21888                                                      10987654321098765432109876543210
21889                                                      x0001111xxxxxxxx0000x0xxxxxxxxxx
21890                                                      fmlal.  */
21891                                                   return 2370;
21892                                                 }
21893                                               else
21894                                                 {
21895                                                   /* 33222222222211111111110000000000
21896                                                      10987654321098765432109876543210
21897                                                      x1001111xxxxxxxx0000x0xxxxxxxxxx
21898                                                      fmlal.  */
21899                                                   return 2374;
21900                                                 }
21901                                             }
21902                                           else
21903                                             {
21904                                               /* 33222222222211111111110000000000
21905                                                  10987654321098765432109876543210
21906                                                  xx101111xxxxxxxx0000x0xxxxxxxxxx
21907                                                  mla.  */
21908                                               return 119;
21909                                             }
21910                                         }
21911                                       else
21912                                         {
21913                                           if (((word >> 29) & 0x1) == 0)
21914                                             {
21915                                               if (((word >> 30) & 0x1) == 0)
21916                                                 {
21917                                                   /* 33222222222211111111110000000000
21918                                                      10987654321098765432109876543210
21919                                                      x0001111xxxxxxxx0100x0xxxxxxxxxx
21920                                                      fmlsl.  */
21921                                                   return 2371;
21922                                                 }
21923                                               else
21924                                                 {
21925                                                   /* 33222222222211111111110000000000
21926                                                      10987654321098765432109876543210
21927                                                      x1001111xxxxxxxx0100x0xxxxxxxxxx
21928                                                      fmlsl.  */
21929                                                   return 2375;
21930                                                 }
21931                                             }
21932                                           else
21933                                             {
21934                                               /* 33222222222211111111110000000000
21935                                                  10987654321098765432109876543210
21936                                                  xx101111xxxxxxxx0100x0xxxxxxxxxx
21937                                                  mls.  */
21938                                               return 122;
21939                                             }
21940                                         }
21941                                     }
21942                                   else
21943                                     {
21944                                       if (((word >> 14) & 0x1) == 0)
21945                                         {
21946                                           if (((word >> 29) & 0x1) == 0)
21947                                             {
21948                                               if (((word >> 30) & 0x1) == 0)
21949                                                 {
21950                                                   /* 33222222222211111111110000000000
21951                                                      10987654321098765432109876543210
21952                                                      x0001111xxxxxxxx0010x0xxxxxxxxxx
21953                                                      smlal.  */
21954                                                   return 98;
21955                                                 }
21956                                               else
21957                                                 {
21958                                                   /* 33222222222211111111110000000000
21959                                                      10987654321098765432109876543210
21960                                                      x1001111xxxxxxxx0010x0xxxxxxxxxx
21961                                                      smlal2.  */
21962                                                   return 99;
21963                                                 }
21964                                             }
21965                                           else
21966                                             {
21967                                               if (((word >> 30) & 0x1) == 0)
21968                                                 {
21969                                                   /* 33222222222211111111110000000000
21970                                                      10987654321098765432109876543210
21971                                                      x0101111xxxxxxxx0010x0xxxxxxxxxx
21972                                                      umlal.  */
21973                                                   return 120;
21974                                                 }
21975                                               else
21976                                                 {
21977                                                   /* 33222222222211111111110000000000
21978                                                      10987654321098765432109876543210
21979                                                      x1101111xxxxxxxx0010x0xxxxxxxxxx
21980                                                      umlal2.  */
21981                                                   return 121;
21982                                                 }
21983                                             }
21984                                         }
21985                                       else
21986                                         {
21987                                           if (((word >> 29) & 0x1) == 0)
21988                                             {
21989                                               if (((word >> 30) & 0x1) == 0)
21990                                                 {
21991                                                   /* 33222222222211111111110000000000
21992                                                      10987654321098765432109876543210
21993                                                      x0001111xxxxxxxx0110x0xxxxxxxxxx
21994                                                      smlsl.  */
21995                                                   return 102;
21996                                                 }
21997                                               else
21998                                                 {
21999                                                   /* 33222222222211111111110000000000
22000                                                      10987654321098765432109876543210
22001                                                      x1001111xxxxxxxx0110x0xxxxxxxxxx
22002                                                      smlsl2.  */
22003                                                   return 103;
22004                                                 }
22005                                             }
22006                                           else
22007                                             {
22008                                               if (((word >> 30) & 0x1) == 0)
22009                                                 {
22010                                                   /* 33222222222211111111110000000000
22011                                                      10987654321098765432109876543210
22012                                                      x0101111xxxxxxxx0110x0xxxxxxxxxx
22013                                                      umlsl.  */
22014                                                   return 123;
22015                                                 }
22016                                               else
22017                                                 {
22018                                                   /* 33222222222211111111110000000000
22019                                                      10987654321098765432109876543210
22020                                                      x1101111xxxxxxxx0110x0xxxxxxxxxx
22021                                                      umlsl2.  */
22022                                                   return 124;
22023                                                 }
22024                                             }
22025                                         }
22026                                     }
22027                                 }
22028                               else
22029                                 {
22030                                   if (((word >> 29) & 0x1) == 0)
22031                                     {
22032                                       if (((word >> 13) & 0x1) == 0)
22033                                         {
22034                                           if (((word >> 14) & 0x1) == 0)
22035                                             {
22036                                               if (((word >> 23) & 0x1) == 0)
22037                                                 {
22038                                                   /* 33222222222211111111110000000000
22039                                                      10987654321098765432109876543210
22040                                                      xx0011110xxxxxxx0001x0xxxxxxxxxx
22041                                                      fmla.  */
22042                                                   return 114;
22043                                                 }
22044                                               else
22045                                                 {
22046                                                   /* 33222222222211111111110000000000
22047                                                      10987654321098765432109876543210
22048                                                      xx0011111xxxxxxx0001x0xxxxxxxxxx
22049                                                      fmla.  */
22050                                                   return 113;
22051                                                 }
22052                                             }
22053                                           else
22054                                             {
22055                                               if (((word >> 23) & 0x1) == 0)
22056                                                 {
22057                                                   /* 33222222222211111111110000000000
22058                                                      10987654321098765432109876543210
22059                                                      xx0011110xxxxxxx0101x0xxxxxxxxxx
22060                                                      fmls.  */
22061                                                   return 116;
22062                                                 }
22063                                               else
22064                                                 {
22065                                                   /* 33222222222211111111110000000000
22066                                                      10987654321098765432109876543210
22067                                                      xx0011111xxxxxxx0101x0xxxxxxxxxx
22068                                                      fmls.  */
22069                                                   return 115;
22070                                                 }
22071                                             }
22072                                         }
22073                                       else
22074                                         {
22075                                           if (((word >> 14) & 0x1) == 0)
22076                                             {
22077                                               if (((word >> 30) & 0x1) == 0)
22078                                                 {
22079                                                   /* 33222222222211111111110000000000
22080                                                      10987654321098765432109876543210
22081                                                      x0001111xxxxxxxx0011x0xxxxxxxxxx
22082                                                      sqdmlal.  */
22083                                                   return 100;
22084                                                 }
22085                                               else
22086                                                 {
22087                                                   /* 33222222222211111111110000000000
22088                                                      10987654321098765432109876543210
22089                                                      x1001111xxxxxxxx0011x0xxxxxxxxxx
22090                                                      sqdmlal2.  */
22091                                                   return 101;
22092                                                 }
22093                                             }
22094                                           else
22095                                             {
22096                                               if (((word >> 30) & 0x1) == 0)
22097                                                 {
22098                                                   /* 33222222222211111111110000000000
22099                                                      10987654321098765432109876543210
22100                                                      x0001111xxxxxxxx0111x0xxxxxxxxxx
22101                                                      sqdmlsl.  */
22102                                                   return 104;
22103                                                 }
22104                                               else
22105                                                 {
22106                                                   /* 33222222222211111111110000000000
22107                                                      10987654321098765432109876543210
22108                                                      x1001111xxxxxxxx0111x0xxxxxxxxxx
22109                                                      sqdmlsl2.  */
22110                                                   return 105;
22111                                                 }
22112                                             }
22113                                         }
22114                                     }
22115                                   else
22116                                     {
22117                                       /* 33222222222211111111110000000000
22118                                          10987654321098765432109876543210
22119                                          xx101111xxxxxxxx0xx1x0xxxxxxxxxx
22120                                          fcmla.  */
22121                                       return 131;
22122                                     }
22123                                 }
22124                             }
22125                           else
22126                             {
22127                               if (((word >> 12) & 0x1) == 0)
22128                                 {
22129                                   if (((word >> 29) & 0x1) == 0)
22130                                     {
22131                                       /* 33222222222211111111110000000000
22132                                          10987654321098765432109876543210
22133                                          xx001111xxxxxxxx0xx0x1xxxxxxxxxx
22134                                          movi.  */
22135                                       return 133;
22136                                     }
22137                                   else
22138                                     {
22139                                       /* 33222222222211111111110000000000
22140                                          10987654321098765432109876543210
22141                                          xx101111xxxxxxxx0xx0x1xxxxxxxxxx
22142                                          mvni.  */
22143                                       return 141;
22144                                     }
22145                                 }
22146                               else
22147                                 {
22148                                   if (((word >> 29) & 0x1) == 0)
22149                                     {
22150                                       /* 33222222222211111111110000000000
22151                                          10987654321098765432109876543210
22152                                          xx001111xxxxxxxx0xx1x1xxxxxxxxxx
22153                                          orr.  */
22154                                       return 134;
22155                                     }
22156                                   else
22157                                     {
22158                                       /* 33222222222211111111110000000000
22159                                          10987654321098765432109876543210
22160                                          xx101111xxxxxxxx0xx1x1xxxxxxxxxx
22161                                          bic.  */
22162                                       return 142;
22163                                     }
22164                                 }
22165                             }
22166                         }
22167                       else
22168                         {
22169                           if (((word >> 29) & 0x1) == 0)
22170                             {
22171                               if (((word >> 30) & 0x1) == 0)
22172                                 {
22173                                   if (((word >> 21) & 0x1) == 0)
22174                                     {
22175                                       /* 33222222222211111111110000000000
22176                                          10987654321098765432109876543210
22177                                          x0011111xx0xxxxx0xxxxxxxxxxxxxxx
22178                                          fmadd.  */
22179                                       return 858;
22180                                     }
22181                                   else
22182                                     {
22183                                       /* 33222222222211111111110000000000
22184                                          10987654321098765432109876543210
22185                                          x0011111xx1xxxxx0xxxxxxxxxxxxxxx
22186                                          fnmadd.  */
22187                                       return 862;
22188                                     }
22189                                 }
22190                               else
22191                                 {
22192                                   if (((word >> 10) & 0x1) == 0)
22193                                     {
22194                                       if (((word >> 13) & 0x1) == 0)
22195                                         {
22196                                           if (((word >> 14) & 0x1) == 0)
22197                                             {
22198                                               if (((word >> 23) & 0x1) == 0)
22199                                                 {
22200                                                   /* 33222222222211111111110000000000
22201                                                      10987654321098765432109876543210
22202                                                      x10111110xxxxxxx000xx0xxxxxxxxxx
22203                                                      fmla.  */
22204                                                   return 431;
22205                                                 }
22206                                               else
22207                                                 {
22208                                                   /* 33222222222211111111110000000000
22209                                                      10987654321098765432109876543210
22210                                                      x10111111xxxxxxx000xx0xxxxxxxxxx
22211                                                      fmla.  */
22212                                                   return 430;
22213                                                 }
22214                                             }
22215                                           else
22216                                             {
22217                                               if (((word >> 23) & 0x1) == 0)
22218                                                 {
22219                                                   /* 33222222222211111111110000000000
22220                                                      10987654321098765432109876543210
22221                                                      x10111110xxxxxxx010xx0xxxxxxxxxx
22222                                                      fmls.  */
22223                                                   return 433;
22224                                                 }
22225                                               else
22226                                                 {
22227                                                   /* 33222222222211111111110000000000
22228                                                      10987654321098765432109876543210
22229                                                      x10111111xxxxxxx010xx0xxxxxxxxxx
22230                                                      fmls.  */
22231                                                   return 432;
22232                                                 }
22233                                             }
22234                                         }
22235                                       else
22236                                         {
22237                                           if (((word >> 14) & 0x1) == 0)
22238                                             {
22239                                               /* 33222222222211111111110000000000
22240                                                  10987654321098765432109876543210
22241                                                  x1011111xxxxxxxx001xx0xxxxxxxxxx
22242                                                  sqdmlal.  */
22243                                               return 425;
22244                                             }
22245                                           else
22246                                             {
22247                                               /* 33222222222211111111110000000000
22248                                                  10987654321098765432109876543210
22249                                                  x1011111xxxxxxxx011xx0xxxxxxxxxx
22250                                                  sqdmlsl.  */
22251                                               return 426;
22252                                             }
22253                                         }
22254                                     }
22255                                   else
22256                                     {
22257                                       if (((word >> 12) & 0x1) == 0)
22258                                         {
22259                                           if (((word >> 13) & 0x1) == 0)
22260                                             {
22261                                               /* 33222222222211111111110000000000
22262                                                  10987654321098765432109876543210
22263                                                  x1011111xxxxxxxx0x00x1xxxxxxxxxx
22264                                                  sshr.  */
22265                                               return 590;
22266                                             }
22267                                           else
22268                                             {
22269                                               /* 33222222222211111111110000000000
22270                                                  10987654321098765432109876543210
22271                                                  x1011111xxxxxxxx0x10x1xxxxxxxxxx
22272                                                  srshr.  */
22273                                               return 592;
22274                                             }
22275                                         }
22276                                       else
22277                                         {
22278                                           if (((word >> 13) & 0x1) == 0)
22279                                             {
22280                                               if (((word >> 14) & 0x1) == 0)
22281                                                 {
22282                                                   /* 33222222222211111111110000000000
22283                                                      10987654321098765432109876543210
22284                                                      x1011111xxxxxxxx0001x1xxxxxxxxxx
22285                                                      ssra.  */
22286                                                   return 591;
22287                                                 }
22288                                               else
22289                                                 {
22290                                                   /* 33222222222211111111110000000000
22291                                                      10987654321098765432109876543210
22292                                                      x1011111xxxxxxxx0101x1xxxxxxxxxx
22293                                                      shl.  */
22294                                                   return 594;
22295                                                 }
22296                                             }
22297                                           else
22298                                             {
22299                                               if (((word >> 14) & 0x1) == 0)
22300                                                 {
22301                                                   /* 33222222222211111111110000000000
22302                                                      10987654321098765432109876543210
22303                                                      x1011111xxxxxxxx0011x1xxxxxxxxxx
22304                                                      srsra.  */
22305                                                   return 593;
22306                                                 }
22307                                               else
22308                                                 {
22309                                                   /* 33222222222211111111110000000000
22310                                                      10987654321098765432109876543210
22311                                                      x1011111xxxxxxxx0111x1xxxxxxxxxx
22312                                                      sqshl.  */
22313                                                   return 595;
22314                                                 }
22315                                             }
22316                                         }
22317                                     }
22318                                 }
22319                             }
22320                           else
22321                             {
22322                               if (((word >> 12) & 0x1) == 0)
22323                                 {
22324                                   if (((word >> 13) & 0x1) == 0)
22325                                     {
22326                                       if (((word >> 14) & 0x1) == 0)
22327                                         {
22328                                           /* 33222222222211111111110000000000
22329                                              10987654321098765432109876543210
22330                                              xx111111xxxxxxxx0000xxxxxxxxxxxx
22331                                              ushr.  */
22332                                           return 602;
22333                                         }
22334                                       else
22335                                         {
22336                                           /* 33222222222211111111110000000000
22337                                              10987654321098765432109876543210
22338                                              xx111111xxxxxxxx0100xxxxxxxxxxxx
22339                                              sri.  */
22340                                           return 606;
22341                                         }
22342                                     }
22343                                   else
22344                                     {
22345                                       if (((word >> 14) & 0x1) == 0)
22346                                         {
22347                                           /* 33222222222211111111110000000000
22348                                              10987654321098765432109876543210
22349                                              xx111111xxxxxxxx0010xxxxxxxxxxxx
22350                                              urshr.  */
22351                                           return 604;
22352                                         }
22353                                       else
22354                                         {
22355                                           /* 33222222222211111111110000000000
22356                                              10987654321098765432109876543210
22357                                              xx111111xxxxxxxx0110xxxxxxxxxxxx
22358                                              sqshlu.  */
22359                                           return 608;
22360                                         }
22361                                     }
22362                                 }
22363                               else
22364                                 {
22365                                   if (((word >> 13) & 0x1) == 0)
22366                                     {
22367                                       if (((word >> 14) & 0x1) == 0)
22368                                         {
22369                                           /* 33222222222211111111110000000000
22370                                              10987654321098765432109876543210
22371                                              xx111111xxxxxxxx0001xxxxxxxxxxxx
22372                                              usra.  */
22373                                           return 603;
22374                                         }
22375                                       else
22376                                         {
22377                                           /* 33222222222211111111110000000000
22378                                              10987654321098765432109876543210
22379                                              xx111111xxxxxxxx0101xxxxxxxxxxxx
22380                                              sli.  */
22381                                           return 607;
22382                                         }
22383                                     }
22384                                   else
22385                                     {
22386                                       if (((word >> 14) & 0x1) == 0)
22387                                         {
22388                                           /* 33222222222211111111110000000000
22389                                              10987654321098765432109876543210
22390                                              xx111111xxxxxxxx0011xxxxxxxxxxxx
22391                                              ursra.  */
22392                                           return 605;
22393                                         }
22394                                       else
22395                                         {
22396                                           /* 33222222222211111111110000000000
22397                                              10987654321098765432109876543210
22398                                              xx111111xxxxxxxx0111xxxxxxxxxxxx
22399                                              uqshl.  */
22400                                           return 609;
22401                                         }
22402                                     }
22403                                 }
22404                             }
22405                         }
22406                     }
22407                   else
22408                     {
22409                       if (((word >> 28) & 0x1) == 0)
22410                         {
22411                           if (((word >> 10) & 0x1) == 0)
22412                             {
22413                               if (((word >> 12) & 0x1) == 0)
22414                                 {
22415                                   if (((word >> 13) & 0x1) == 0)
22416                                     {
22417                                       if (((word >> 14) & 0x1) == 0)
22418                                         {
22419                                           if (((word >> 29) & 0x1) == 0)
22420                                             {
22421                                               /* 33222222222211111111110000000000
22422                                                  10987654321098765432109876543210
22423                                                  xx001111xxxxxxxx1000x0xxxxxxxxxx
22424                                                  mul.  */
22425                                               return 106;
22426                                             }
22427                                           else
22428                                             {
22429                                               if (((word >> 30) & 0x1) == 0)
22430                                                 {
22431                                                   /* 33222222222211111111110000000000
22432                                                      10987654321098765432109876543210
22433                                                      x0101111xxxxxxxx1000x0xxxxxxxxxx
22434                                                      fmlal2.  */
22435                                                   return 2372;
22436                                                 }
22437                                               else
22438                                                 {
22439                                                   /* 33222222222211111111110000000000
22440                                                      10987654321098765432109876543210
22441                                                      x1101111xxxxxxxx1000x0xxxxxxxxxx
22442                                                      fmlal2.  */
22443                                                   return 2376;
22444                                                 }
22445                                             }
22446                                         }
22447                                       else
22448                                         {
22449                                           if (((word >> 29) & 0x1) == 0)
22450                                             {
22451                                               /* 33222222222211111111110000000000
22452                                                  10987654321098765432109876543210
22453                                                  xx001111xxxxxxxx1100x0xxxxxxxxxx
22454                                                  sqdmulh.  */
22455                                               return 111;
22456                                             }
22457                                           else
22458                                             {
22459                                               if (((word >> 30) & 0x1) == 0)
22460                                                 {
22461                                                   /* 33222222222211111111110000000000
22462                                                      10987654321098765432109876543210
22463                                                      x0101111xxxxxxxx1100x0xxxxxxxxxx
22464                                                      fmlsl2.  */
22465                                                   return 2373;
22466                                                 }
22467                                               else
22468                                                 {
22469                                                   /* 33222222222211111111110000000000
22470                                                      10987654321098765432109876543210
22471                                                      x1101111xxxxxxxx1100x0xxxxxxxxxx
22472                                                      fmlsl2.  */
22473                                                   return 2377;
22474                                                 }
22475                                             }
22476                                         }
22477                                     }
22478                                   else
22479                                     {
22480                                       if (((word >> 14) & 0x1) == 0)
22481                                         {
22482                                           if (((word >> 29) & 0x1) == 0)
22483                                             {
22484                                               if (((word >> 30) & 0x1) == 0)
22485                                                 {
22486                                                   /* 33222222222211111111110000000000
22487                                                      10987654321098765432109876543210
22488                                                      x0001111xxxxxxxx1010x0xxxxxxxxxx
22489                                                      smull.  */
22490                                                   return 107;
22491                                                 }
22492                                               else
22493                                                 {
22494                                                   /* 33222222222211111111110000000000
22495                                                      10987654321098765432109876543210
22496                                                      x1001111xxxxxxxx1010x0xxxxxxxxxx
22497                                                      smull2.  */
22498                                                   return 108;
22499                                                 }
22500                                             }
22501                                           else
22502                                             {
22503                                               if (((word >> 30) & 0x1) == 0)
22504                                                 {
22505                                                   /* 33222222222211111111110000000000
22506                                                      10987654321098765432109876543210
22507                                                      x0101111xxxxxxxx1010x0xxxxxxxxxx
22508                                                      umull.  */
22509                                                   return 125;
22510                                                 }
22511                                               else
22512                                                 {
22513                                                   /* 33222222222211111111110000000000
22514                                                      10987654321098765432109876543210
22515                                                      x1101111xxxxxxxx1010x0xxxxxxxxxx
22516                                                      umull2.  */
22517                                                   return 126;
22518                                                 }
22519                                             }
22520                                         }
22521                                       else
22522                                         {
22523                                           if (((word >> 29) & 0x1) == 0)
22524                                             {
22525                                               /* 33222222222211111111110000000000
22526                                                  10987654321098765432109876543210
22527                                                  xx001111xxxxxxxx1110x0xxxxxxxxxx
22528                                                  sdot.  */
22529                                               return 2344;
22530                                             }
22531                                           else
22532                                             {
22533                                               /* 33222222222211111111110000000000
22534                                                  10987654321098765432109876543210
22535                                                  xx101111xxxxxxxx1110x0xxxxxxxxxx
22536                                                  udot.  */
22537                                               return 2343;
22538                                             }
22539                                         }
22540                                     }
22541                                 }
22542                               else
22543                                 {
22544                                   if (((word >> 13) & 0x1) == 0)
22545                                     {
22546                                       if (((word >> 14) & 0x1) == 0)
22547                                         {
22548                                           if (((word >> 23) & 0x1) == 0)
22549                                             {
22550                                               if (((word >> 29) & 0x1) == 0)
22551                                                 {
22552                                                   /* 33222222222211111111110000000000
22553                                                      10987654321098765432109876543210
22554                                                      xx0011110xxxxxxx1001x0xxxxxxxxxx
22555                                                      fmul.  */
22556                                                   return 118;
22557                                                 }
22558                                               else
22559                                                 {
22560                                                   /* 33222222222211111111110000000000
22561                                                      10987654321098765432109876543210
22562                                                      xx1011110xxxxxxx1001x0xxxxxxxxxx
22563                                                      fmulx.  */
22564                                                   return 128;
22565                                                 }
22566                                             }
22567                                           else
22568                                             {
22569                                               if (((word >> 29) & 0x1) == 0)
22570                                                 {
22571                                                   /* 33222222222211111111110000000000
22572                                                      10987654321098765432109876543210
22573                                                      xx0011111xxxxxxx1001x0xxxxxxxxxx
22574                                                      fmul.  */
22575                                                   return 117;
22576                                                 }
22577                                               else
22578                                                 {
22579                                                   /* 33222222222211111111110000000000
22580                                                      10987654321098765432109876543210
22581                                                      xx1011111xxxxxxx1001x0xxxxxxxxxx
22582                                                      fmulx.  */
22583                                                   return 127;
22584                                                 }
22585                                             }
22586                                         }
22587                                       else
22588                                         {
22589                                           if (((word >> 29) & 0x1) == 0)
22590                                             {
22591                                               /* 33222222222211111111110000000000
22592                                                  10987654321098765432109876543210
22593                                                  xx001111xxxxxxxx1101x0xxxxxxxxxx
22594                                                  sqrdmulh.  */
22595                                               return 112;
22596                                             }
22597                                           else
22598                                             {
22599                                               /* 33222222222211111111110000000000
22600                                                  10987654321098765432109876543210
22601                                                  xx101111xxxxxxxx1101x0xxxxxxxxxx
22602                                                  sqrdmlah.  */
22603                                               return 129;
22604                                             }
22605                                         }
22606                                     }
22607                                   else
22608                                     {
22609                                       if (((word >> 14) & 0x1) == 0)
22610                                         {
22611                                           if (((word >> 30) & 0x1) == 0)
22612                                             {
22613                                               /* 33222222222211111111110000000000
22614                                                  10987654321098765432109876543210
22615                                                  x0x01111xxxxxxxx1011x0xxxxxxxxxx
22616                                                  sqdmull.  */
22617                                               return 109;
22618                                             }
22619                                           else
22620                                             {
22621                                               /* 33222222222211111111110000000000
22622                                                  10987654321098765432109876543210
22623                                                  x1x01111xxxxxxxx1011x0xxxxxxxxxx
22624                                                  sqdmull2.  */
22625                                               return 110;
22626                                             }
22627                                         }
22628                                       else
22629                                         {
22630                                           if (((word >> 29) & 0x1) == 0)
22631                                             {
22632                                               if (((word >> 22) & 0x1) == 0)
22633                                                 {
22634                                                   if (((word >> 23) & 0x1) == 0)
22635                                                     {
22636                                                       /* 33222222222211111111110000000000
22637                                                          10987654321098765432109876543210
22638                                                          xx00111100xxxxxx1111x0xxxxxxxxxx
22639                                                          sudot.  */
22640                                                       return 2421;
22641                                                     }
22642                                                   else
22643                                                     {
22644                                                       /* 33222222222211111111110000000000
22645                                                          10987654321098765432109876543210
22646                                                          xx00111110xxxxxx1111x0xxxxxxxxxx
22647                                                          usdot.  */
22648                                                       return 2420;
22649                                                     }
22650                                                 }
22651                                               else
22652                                                 {
22653                                                   if (((word >> 23) & 0x1) == 0)
22654                                                     {
22655                                                       /* 33222222222211111111110000000000
22656                                                          10987654321098765432109876543210
22657                                                          xx00111101xxxxxx1111x0xxxxxxxxxx
22658                                                          bfdot.  */
22659                                                       return 2432;
22660                                                     }
22661                                                   else
22662                                                     {
22663                                                       if (((word >> 30) & 0x1) == 0)
22664                                                         {
22665                                                           /* 33222222222211111111110000000000
22666                                                              10987654321098765432109876543210
22667                                                              x000111111xxxxxx1111x0xxxxxxxxxx
22668                                                              bfmlalb.  */
22669                                                           return 2440;
22670                                                         }
22671                                                       else
22672                                                         {
22673                                                           /* 33222222222211111111110000000000
22674                                                              10987654321098765432109876543210
22675                                                              x100111111xxxxxx1111x0xxxxxxxxxx
22676                                                              bfmlalt.  */
22677                                                           return 2439;
22678                                                         }
22679                                                     }
22680                                                 }
22681                                             }
22682                                           else
22683                                             {
22684                                               /* 33222222222211111111110000000000
22685                                                  10987654321098765432109876543210
22686                                                  xx101111xxxxxxxx1111x0xxxxxxxxxx
22687                                                  sqrdmlsh.  */
22688                                               return 130;
22689                                             }
22690                                         }
22691                                     }
22692                                 }
22693                             }
22694                           else
22695                             {
22696                               if (((word >> 11) & 0x1) == 0)
22697                                 {
22698                                   if (((word >> 14) & 0x1) == 0)
22699                                     {
22700                                       if (((word >> 12) & 0x1) == 0)
22701                                         {
22702                                           if (((word >> 29) & 0x1) == 0)
22703                                             {
22704                                               /* 33222222222211111111110000000000
22705                                                  10987654321098765432109876543210
22706                                                  xx001111xxxxxxxx10x001xxxxxxxxxx
22707                                                  movi.  */
22708                                               return 135;
22709                                             }
22710                                           else
22711                                             {
22712                                               /* 33222222222211111111110000000000
22713                                                  10987654321098765432109876543210
22714                                                  xx101111xxxxxxxx10x001xxxxxxxxxx
22715                                                  mvni.  */
22716                                               return 143;
22717                                             }
22718                                         }
22719                                       else
22720                                         {
22721                                           if (((word >> 29) & 0x1) == 0)
22722                                             {
22723                                               /* 33222222222211111111110000000000
22724                                                  10987654321098765432109876543210
22725                                                  xx001111xxxxxxxx10x101xxxxxxxxxx
22726                                                  orr.  */
22727                                               return 136;
22728                                             }
22729                                           else
22730                                             {
22731                                               /* 33222222222211111111110000000000
22732                                                  10987654321098765432109876543210
22733                                                  xx101111xxxxxxxx10x101xxxxxxxxxx
22734                                                  bic.  */
22735                                               return 144;
22736                                             }
22737                                         }
22738                                     }
22739                                   else
22740                                     {
22741                                       if (((word >> 13) & 0x1) == 0)
22742                                         {
22743                                           if (((word >> 29) & 0x1) == 0)
22744                                             {
22745                                               /* 33222222222211111111110000000000
22746                                                  10987654321098765432109876543210
22747                                                  xx001111xxxxxxxx110x01xxxxxxxxxx
22748                                                  movi.  */
22749                                               return 137;
22750                                             }
22751                                           else
22752                                             {
22753                                               /* 33222222222211111111110000000000
22754                                                  10987654321098765432109876543210
22755                                                  xx101111xxxxxxxx110x01xxxxxxxxxx
22756                                                  mvni.  */
22757                                               return 145;
22758                                             }
22759                                         }
22760                                       else
22761                                         {
22762                                           if (((word >> 12) & 0x1) == 0)
22763                                             {
22764                                               if (((word >> 29) & 0x1) == 0)
22765                                                 {
22766                                                   /* 33222222222211111111110000000000
22767                                                      10987654321098765432109876543210
22768                                                      xx001111xxxxxxxx111001xxxxxxxxxx
22769                                                      movi.  */
22770                                                   return 138;
22771                                                 }
22772                                               else
22773                                                 {
22774                                                   /* 33222222222211111111110000000000
22775                                                      10987654321098765432109876543210
22776                                                      xx101111xxxxxxxx111001xxxxxxxxxx
22777                                                      movi.  */
22778                                                   return 146;
22779                                                 }
22780                                             }
22781                                           else
22782                                             {
22783                                               if (((word >> 29) & 0x1) == 0)
22784                                                 {
22785                                                   /* 33222222222211111111110000000000
22786                                                      10987654321098765432109876543210
22787                                                      xx001111xxxxxxxx111101xxxxxxxxxx
22788                                                      fmov.  */
22789                                                   return 139;
22790                                                 }
22791                                               else
22792                                                 {
22793                                                   /* 33222222222211111111110000000000
22794                                                      10987654321098765432109876543210
22795                                                      xx101111xxxxxxxx111101xxxxxxxxxx
22796                                                      fmov.  */
22797                                                   return 148;
22798                                                 }
22799                                             }
22800                                         }
22801                                     }
22802                                 }
22803                               else
22804                                 {
22805                                   if (((word >> 12) & 0x1) == 0)
22806                                     {
22807                                       if (((word >> 29) & 0x1) == 0)
22808                                         {
22809                                           if (((word >> 30) & 0x1) == 0)
22810                                             {
22811                                               /* 33222222222211111111110000000000
22812                                                  10987654321098765432109876543210
22813                                                  x0001111xxxxxxxx1xx011xxxxxxxxxx
22814                                                  rshrn.  */
22815                                               return 382;
22816                                             }
22817                                           else
22818                                             {
22819                                               /* 33222222222211111111110000000000
22820                                                  10987654321098765432109876543210
22821                                                  x1001111xxxxxxxx1xx011xxxxxxxxxx
22822                                                  rshrn2.  */
22823                                               return 383;
22824                                             }
22825                                         }
22826                                       else
22827                                         {
22828                                           if (((word >> 30) & 0x1) == 0)
22829                                             {
22830                                               /* 33222222222211111111110000000000
22831                                                  10987654321098765432109876543210
22832                                                  x0101111xxxxxxxx1xx011xxxxxxxxxx
22833                                                  sqrshrun.  */
22834                                               return 406;
22835                                             }
22836                                           else
22837                                             {
22838                                               /* 33222222222211111111110000000000
22839                                                  10987654321098765432109876543210
22840                                                  x1101111xxxxxxxx1xx011xxxxxxxxxx
22841                                                  sqrshrun2.  */
22842                                               return 407;
22843                                             }
22844                                         }
22845                                     }
22846                                   else
22847                                     {
22848                                       if (((word >> 13) & 0x1) == 0)
22849                                         {
22850                                           if (((word >> 29) & 0x1) == 0)
22851                                             {
22852                                               if (((word >> 30) & 0x1) == 0)
22853                                                 {
22854                                                   /* 33222222222211111111110000000000
22855                                                      10987654321098765432109876543210
22856                                                      x0001111xxxxxxxx1x0111xxxxxxxxxx
22857                                                      sqrshrn.  */
22858                                                   return 386;
22859                                                 }
22860                                               else
22861                                                 {
22862                                                   /* 33222222222211111111110000000000
22863                                                      10987654321098765432109876543210
22864                                                      x1001111xxxxxxxx1x0111xxxxxxxxxx
22865                                                      sqrshrn2.  */
22866                                                   return 387;
22867                                                 }
22868                                             }
22869                                           else
22870                                             {
22871                                               if (((word >> 30) & 0x1) == 0)
22872                                                 {
22873                                                   /* 33222222222211111111110000000000
22874                                                      10987654321098765432109876543210
22875                                                      x0101111xxxxxxxx1x0111xxxxxxxxxx
22876                                                      uqrshrn.  */
22877                                                   return 410;
22878                                                 }
22879                                               else
22880                                                 {
22881                                                   /* 33222222222211111111110000000000
22882                                                      10987654321098765432109876543210
22883                                                      x1101111xxxxxxxx1x0111xxxxxxxxxx
22884                                                      uqrshrn2.  */
22885                                                   return 411;
22886                                                 }
22887                                             }
22888                                         }
22889                                       else
22890                                         {
22891                                           if (((word >> 29) & 0x1) == 0)
22892                                             {
22893                                               /* 33222222222211111111110000000000
22894                                                  10987654321098765432109876543210
22895                                                  xx001111xxxxxxxx1x1111xxxxxxxxxx
22896                                                  fmov.  */
22897                                               return 140;
22898                                             }
22899                                           else
22900                                             {
22901                                               /* 33222222222211111111110000000000
22902                                                  10987654321098765432109876543210
22903                                                  xx101111xxxxxxxx1x1111xxxxxxxxxx
22904                                                  fcvtzu.  */
22905                                               return 418;
22906                                             }
22907                                         }
22908                                     }
22909                                 }
22910                             }
22911                         }
22912                       else
22913                         {
22914                           if (((word >> 29) & 0x1) == 0)
22915                             {
22916                               if (((word >> 30) & 0x1) == 0)
22917                                 {
22918                                   if (((word >> 21) & 0x1) == 0)
22919                                     {
22920                                       /* 33222222222211111111110000000000
22921                                          10987654321098765432109876543210
22922                                          x0011111xx0xxxxx1xxxxxxxxxxxxxxx
22923                                          fmsub.  */
22924                                       return 860;
22925                                     }
22926                                   else
22927                                     {
22928                                       /* 33222222222211111111110000000000
22929                                          10987654321098765432109876543210
22930                                          x0011111xx1xxxxx1xxxxxxxxxxxxxxx
22931                                          fnmsub.  */
22932                                       return 864;
22933                                     }
22934                                 }
22935                               else
22936                                 {
22937                                   if (((word >> 10) & 0x1) == 0)
22938                                     {
22939                                       if (((word >> 12) & 0x1) == 0)
22940                                         {
22941                                           /* 33222222222211111111110000000000
22942                                              10987654321098765432109876543210
22943                                              x1011111xxxxxxxx1xx0x0xxxxxxxxxx
22944                                              sqdmulh.  */
22945                                           return 428;
22946                                         }
22947                                       else
22948                                         {
22949                                           if (((word >> 13) & 0x1) == 0)
22950                                             {
22951                                               if (((word >> 14) & 0x1) == 0)
22952                                                 {
22953                                                   if (((word >> 23) & 0x1) == 0)
22954                                                     {
22955                                                       /* 33222222222211111111110000000000
22956                                                          10987654321098765432109876543210
22957                                                          x10111110xxxxxxx1001x0xxxxxxxxxx
22958                                                          fmul.  */
22959                                                       return 435;
22960                                                     }
22961                                                   else
22962                                                     {
22963                                                       /* 33222222222211111111110000000000
22964                                                          10987654321098765432109876543210
22965                                                          x10111111xxxxxxx1001x0xxxxxxxxxx
22966                                                          fmul.  */
22967                                                       return 434;
22968                                                     }
22969                                                 }
22970                                               else
22971                                                 {
22972                                                   /* 33222222222211111111110000000000
22973                                                      10987654321098765432109876543210
22974                                                      x1011111xxxxxxxx1101x0xxxxxxxxxx
22975                                                      sqrdmulh.  */
22976                                                   return 429;
22977                                                 }
22978                                             }
22979                                           else
22980                                             {
22981                                               /* 33222222222211111111110000000000
22982                                                  10987654321098765432109876543210
22983                                                  x1011111xxxxxxxx1x11x0xxxxxxxxxx
22984                                                  sqdmull.  */
22985                                               return 427;
22986                                             }
22987                                         }
22988                                     }
22989                                   else
22990                                     {
22991                                       if (((word >> 11) & 0x1) == 0)
22992                                         {
22993                                           if (((word >> 12) & 0x1) == 0)
22994                                             {
22995                                               /* 33222222222211111111110000000000
22996                                                  10987654321098765432109876543210
22997                                                  x1011111xxxxxxxx1xx001xxxxxxxxxx
22998                                                  scvtf.  */
22999                                               return 598;
23000                                             }
23001                                           else
23002                                             {
23003                                               /* 33222222222211111111110000000000
23004                                                  10987654321098765432109876543210
23005                                                  x1011111xxxxxxxx1xx101xxxxxxxxxx
23006                                                  sqshrn.  */
23007                                               return 596;
23008                                             }
23009                                         }
23010                                       else
23011                                         {
23012                                           if (((word >> 13) & 0x1) == 0)
23013                                             {
23014                                               /* 33222222222211111111110000000000
23015                                                  10987654321098765432109876543210
23016                                                  x1011111xxxxxxxx1x0x11xxxxxxxxxx
23017                                                  sqrshrn.  */
23018                                               return 597;
23019                                             }
23020                                           else
23021                                             {
23022                                               /* 33222222222211111111110000000000
23023                                                  10987654321098765432109876543210
23024                                                  x1011111xxxxxxxx1x1x11xxxxxxxxxx
23025                                                  fcvtzs.  */
23026                                               return 600;
23027                                             }
23028                                         }
23029                                     }
23030                                 }
23031                             }
23032                           else
23033                             {
23034                               if (((word >> 10) & 0x1) == 0)
23035                                 {
23036                                   if (((word >> 13) & 0x1) == 0)
23037                                     {
23038                                       if (((word >> 14) & 0x1) == 0)
23039                                         {
23040                                           if (((word >> 23) & 0x1) == 0)
23041                                             {
23042                                               /* 33222222222211111111110000000000
23043                                                  10987654321098765432109876543210
23044                                                  xx1111110xxxxxxx100xx0xxxxxxxxxx
23045                                                  fmulx.  */
23046                                               return 437;
23047                                             }
23048                                           else
23049                                             {
23050                                               /* 33222222222211111111110000000000
23051                                                  10987654321098765432109876543210
23052                                                  xx1111111xxxxxxx100xx0xxxxxxxxxx
23053                                                  fmulx.  */
23054                                               return 436;
23055                                             }
23056                                         }
23057                                       else
23058                                         {
23059                                           /* 33222222222211111111110000000000
23060                                              10987654321098765432109876543210
23061                                              xx111111xxxxxxxx110xx0xxxxxxxxxx
23062                                              sqrdmlah.  */
23063                                           return 438;
23064                                         }
23065                                     }
23066                                   else
23067                                     {
23068                                       /* 33222222222211111111110000000000
23069                                          10987654321098765432109876543210
23070                                          xx111111xxxxxxxx1x1xx0xxxxxxxxxx
23071                                          sqrdmlsh.  */
23072                                       return 439;
23073                                     }
23074                                 }
23075                               else
23076                                 {
23077                                   if (((word >> 11) & 0x1) == 0)
23078                                     {
23079                                       if (((word >> 12) & 0x1) == 0)
23080                                         {
23081                                           if (((word >> 13) & 0x1) == 0)
23082                                             {
23083                                               /* 33222222222211111111110000000000
23084                                                  10987654321098765432109876543210
23085                                                  xx111111xxxxxxxx1x0001xxxxxxxxxx
23086                                                  sqshrun.  */
23087                                               return 610;
23088                                             }
23089                                           else
23090                                             {
23091                                               /* 33222222222211111111110000000000
23092                                                  10987654321098765432109876543210
23093                                                  xx111111xxxxxxxx1x1001xxxxxxxxxx
23094                                                  ucvtf.  */
23095                                               return 614;
23096                                             }
23097                                         }
23098                                       else
23099                                         {
23100                                           /* 33222222222211111111110000000000
23101                                              10987654321098765432109876543210
23102                                              xx111111xxxxxxxx1xx101xxxxxxxxxx
23103                                              uqshrn.  */
23104                                           return 612;
23105                                         }
23106                                     }
23107                                   else
23108                                     {
23109                                       if (((word >> 12) & 0x1) == 0)
23110                                         {
23111                                           /* 33222222222211111111110000000000
23112                                              10987654321098765432109876543210
23113                                              xx111111xxxxxxxx1xx011xxxxxxxxxx
23114                                              sqrshrun.  */
23115                                           return 611;
23116                                         }
23117                                       else
23118                                         {
23119                                           if (((word >> 13) & 0x1) == 0)
23120                                             {
23121                                               /* 33222222222211111111110000000000
23122                                                  10987654321098765432109876543210
23123                                                  xx111111xxxxxxxx1x0111xxxxxxxxxx
23124                                                  uqrshrn.  */
23125                                               return 613;
23126                                             }
23127                                           else
23128                                             {
23129                                               /* 33222222222211111111110000000000
23130                                                  10987654321098765432109876543210
23131                                                  xx111111xxxxxxxx1x1111xxxxxxxxxx
23132                                                  fcvtzu.  */
23133                                               return 616;
23134                                             }
23135                                         }
23136                                     }
23137                                 }
23138                             }
23139                         }
23140                     }
23141                 }
23142             }
23143         }
23144     }
23145 }
23146 
23147 /* Lookup opcode WORD in the opcode table.  N.B. all alias
23148    opcodes are ignored here.  */
23149 
23150 const aarch64_opcode *
23151 aarch64_opcode_lookup (uint32_t word)
23152 {
23153   return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);
23154 }
23155 
23156 const aarch64_opcode *
23157 aarch64_find_next_opcode (const aarch64_opcode *opcode)
23158 {
23159   /* Use the index as the key to locate the next opcode.  */
23160   int key = opcode - aarch64_opcode_table;
23161   int value;
23162   switch (key)
23163     {
23164     case 12: value = 19; break;	/* add --> addg.  */
23165     case 19: return NULL;		/* addg --> NULL.  */
23166     case 16: value = 20; break;	/* sub --> subg.  */
23167     case 20: return NULL;		/* subg --> NULL.  */
23168     case 971: value = 975; break;	/* stnp --> stp.  */
23169     case 975: return NULL;		/* stp --> NULL.  */
23170     case 969: value = 970; break;	/* stllrb --> stllrh.  */
23171     case 970: return NULL;		/* stllrh --> NULL.  */
23172     case 972: value = 976; break;	/* ldnp --> ldp.  */
23173     case 976: return NULL;		/* ldp --> NULL.  */
23174     case 1629: value = 1630; break;	/* ldff1b --> ldff1b.  */
23175     case 1630: return NULL;		/* ldff1b --> NULL.  */
23176     case 1685: value = 1686; break;	/* ldff1sw --> ldff1sw.  */
23177     case 1686: return NULL;		/* ldff1sw --> NULL.  */
23178     case 1633: value = 1634; break;	/* ldff1b --> ldff1b.  */
23179     case 1634: return NULL;		/* ldff1b --> NULL.  */
23180     case 1652: value = 1653; break;	/* ldff1h --> ldff1h.  */
23181     case 1653: return NULL;		/* ldff1h --> NULL.  */
23182     case 1631: value = 1632; break;	/* ldff1b --> ldff1b.  */
23183     case 1632: return NULL;		/* ldff1b --> NULL.  */
23184     case 1650: value = 1651; break;	/* ldff1h --> ldff1h.  */
23185     case 1651: return NULL;		/* ldff1h --> NULL.  */
23186     case 1635: value = 1636; break;	/* ldff1b --> ldff1b.  */
23187     case 1636: return NULL;		/* ldff1b --> NULL.  */
23188     case 1654: value = 1655; break;	/* ldff1h --> ldff1h.  */
23189     case 1655: return NULL;		/* ldff1h --> NULL.  */
23190     case 1675: value = 1676; break;	/* ldff1sh --> ldff1sh.  */
23191     case 1676: return NULL;		/* ldff1sh --> NULL.  */
23192     case 1663: value = 1664; break;	/* ldff1sb --> ldff1sb.  */
23193     case 1664: return NULL;		/* ldff1sb --> NULL.  */
23194     case 1694: value = 1695; break;	/* ldff1w --> ldff1w.  */
23195     case 1695: return NULL;		/* ldff1w --> NULL.  */
23196     case 1667: value = 1668; break;	/* ldff1sb --> ldff1sb.  */
23197     case 1668: return NULL;		/* ldff1sb --> NULL.  */
23198     case 1677: value = 1678; break;	/* ldff1sh --> ldff1sh.  */
23199     case 1678: return NULL;		/* ldff1sh --> NULL.  */
23200     case 1665: value = 1666; break;	/* ldff1sb --> ldff1sb.  */
23201     case 1666: return NULL;		/* ldff1sb --> NULL.  */
23202     case 1696: value = 1697; break;	/* ldff1w --> ldff1w.  */
23203     case 1697: return NULL;		/* ldff1w --> NULL.  */
23204     case 1641: value = 1642; break;	/* ldff1d --> ldff1d.  */
23205     case 1642: return NULL;		/* ldff1d --> NULL.  */
23206     case 811: value = 812; break;	/* xaflag --> axflag.  */
23207     case 812: value = 1190; break;	/* axflag --> tcommit.  */
23208     case 1190: value = 1193; break;	/* tcommit --> msr.  */
23209     case 1193: value = 1194; break;	/* msr --> hint.  */
23210     case 1194: value = 1203; break;	/* hint --> dgh.  */
23211     case 1203: value = 1212; break;	/* dgh --> clrex.  */
23212     case 1212: value = 1213; break;	/* clrex --> dsb.  */
23213     case 1213: value = 1217; break;	/* dsb --> dmb.  */
23214     case 1217: value = 1218; break;	/* dmb --> isb.  */
23215     case 1218: value = 1219; break;	/* isb --> sb.  */
23216     case 1219: value = 1220; break;	/* sb --> sys.  */
23217     case 1220: value = 1228; break;	/* sys --> cfinv.  */
23218     case 1228: value = 1229; break;	/* cfinv --> msr.  */
23219     case 1229: return NULL;		/* msr --> NULL.  */
23220     case 1189: value = 1191; break;	/* tstart --> ttest.  */
23221     case 1191: value = 1230; break;	/* ttest --> sysl.  */
23222     case 1230: value = 1231; break;	/* sysl --> mrs.  */
23223     case 1231: return NULL;		/* mrs --> NULL.  */
23224     case 440: value = 441; break;	/* st4 --> st1.  */
23225     case 441: value = 442; break;	/* st1 --> st2.  */
23226     case 442: value = 443; break;	/* st2 --> st3.  */
23227     case 443: return NULL;		/* st3 --> NULL.  */
23228     case 448: value = 449; break;	/* st4 --> st1.  */
23229     case 449: value = 450; break;	/* st1 --> st2.  */
23230     case 450: value = 451; break;	/* st2 --> st3.  */
23231     case 451: return NULL;		/* st3 --> NULL.  */
23232     case 444: value = 445; break;	/* ld4 --> ld1.  */
23233     case 445: value = 446; break;	/* ld1 --> ld2.  */
23234     case 446: value = 447; break;	/* ld2 --> ld3.  */
23235     case 447: return NULL;		/* ld3 --> NULL.  */
23236     case 460: value = 462; break;	/* ld1 --> ld1r.  */
23237     case 462: return NULL;		/* ld1r --> NULL.  */
23238     case 464: value = 466; break;	/* ld2 --> ld2r.  */
23239     case 466: return NULL;		/* ld2r --> NULL.  */
23240     case 461: value = 463; break;	/* ld3 --> ld3r.  */
23241     case 463: return NULL;		/* ld3r --> NULL.  */
23242     case 465: value = 467; break;	/* ld4 --> ld4r.  */
23243     case 467: return NULL;		/* ld4r --> NULL.  */
23244     case 452: value = 453; break;	/* ld4 --> ld1.  */
23245     case 453: value = 454; break;	/* ld1 --> ld2.  */
23246     case 454: value = 455; break;	/* ld2 --> ld3.  */
23247     case 455: return NULL;		/* ld3 --> NULL.  */
23248     case 472: value = 474; break;	/* ld1 --> ld1r.  */
23249     case 474: return NULL;		/* ld1r --> NULL.  */
23250     case 473: value = 475; break;	/* ld3 --> ld3r.  */
23251     case 475: return NULL;		/* ld3r --> NULL.  */
23252     case 476: value = 478; break;	/* ld2 --> ld2r.  */
23253     case 478: return NULL;		/* ld2r --> NULL.  */
23254     case 477: value = 479; break;	/* ld4 --> ld4r.  */
23255     case 479: return NULL;		/* ld4r --> NULL.  */
23256     case 764: value = 765; break;	/* fcvtzs --> fcvtzs.  */
23257     case 765: return NULL;		/* fcvtzs --> NULL.  */
23258     case 760: value = 761; break;	/* scvtf --> scvtf.  */
23259     case 761: return NULL;		/* scvtf --> NULL.  */
23260     case 766: value = 767; break;	/* fcvtzu --> fcvtzu.  */
23261     case 767: return NULL;		/* fcvtzu --> NULL.  */
23262     case 762: value = 763; break;	/* ucvtf --> ucvtf.  */
23263     case 763: return NULL;		/* ucvtf --> NULL.  */
23264     case 768: value = 769; break;	/* fcvtns --> fcvtns.  */
23265     case 769: return NULL;		/* fcvtns --> NULL.  */
23266     case 788: value = 789; break;	/* fcvtms --> fcvtms.  */
23267     case 789: return NULL;		/* fcvtms --> NULL.  */
23268     case 784: value = 785; break;	/* fcvtps --> fcvtps.  */
23269     case 785: return NULL;		/* fcvtps --> NULL.  */
23270     case 792: value = 793; break;	/* fcvtzs --> fcvtzs.  */
23271     case 793: return NULL;		/* fcvtzs --> NULL.  */
23272     case 776: value = 777; break;	/* fcvtas --> fcvtas.  */
23273     case 777: return NULL;		/* fcvtas --> NULL.  */
23274     case 772: value = 773; break;	/* scvtf --> scvtf.  */
23275     case 773: return NULL;		/* scvtf --> NULL.  */
23276     case 780: value = 781; break;	/* fmov --> fmov.  */
23277     case 781: return NULL;		/* fmov --> NULL.  */
23278     case 770: value = 771; break;	/* fcvtnu --> fcvtnu.  */
23279     case 771: return NULL;		/* fcvtnu --> NULL.  */
23280     case 790: value = 791; break;	/* fcvtmu --> fcvtmu.  */
23281     case 791: return NULL;		/* fcvtmu --> NULL.  */
23282     case 786: value = 787; break;	/* fcvtpu --> fcvtpu.  */
23283     case 787: return NULL;		/* fcvtpu --> NULL.  */
23284     case 794: value = 795; break;	/* fcvtzu --> fcvtzu.  */
23285     case 795: return NULL;		/* fcvtzu --> NULL.  */
23286     case 778: value = 779; break;	/* fcvtau --> fcvtau.  */
23287     case 779: return NULL;		/* fcvtau --> NULL.  */
23288     case 774: value = 775; break;	/* ucvtf --> ucvtf.  */
23289     case 775: return NULL;		/* ucvtf --> NULL.  */
23290     case 782: value = 783; break;	/* fmov --> fmov.  */
23291     case 783: return NULL;		/* fmov --> NULL.  */
23292     case 817: value = 818; break;	/* fmov --> fmov.  */
23293     case 818: return NULL;		/* fmov --> NULL.  */
23294     case 826: value = 827; break;	/* frintn --> frintn.  */
23295     case 827: return NULL;		/* frintn --> NULL.  */
23296     case 821: value = 822; break;	/* fneg --> fneg.  */
23297     case 822: return NULL;		/* fneg --> NULL.  */
23298     case 830: value = 831; break;	/* frintm --> frintm.  */
23299     case 831: return NULL;		/* frintm --> NULL.  */
23300     case 819: value = 820; break;	/* fabs --> fabs.  */
23301     case 820: return NULL;		/* fabs --> NULL.  */
23302     case 828: value = 829; break;	/* frintp --> frintp.  */
23303     case 829: return NULL;		/* frintp --> NULL.  */
23304     case 823: value = 824; break;	/* fsqrt --> fsqrt.  */
23305     case 824: return NULL;		/* fsqrt --> NULL.  */
23306     case 832: value = 833; break;	/* frintz --> frintz.  */
23307     case 833: return NULL;		/* frintz --> NULL.  */
23308     case 825: value = 2436; break;	/* fcvt --> bfcvt.  */
23309     case 2436: return NULL;		/* bfcvt --> NULL.  */
23310     case 834: value = 835; break;	/* frinta --> frinta.  */
23311     case 835: return NULL;		/* frinta --> NULL.  */
23312     case 836: value = 837; break;	/* frintx --> frintx.  */
23313     case 837: return NULL;		/* frintx --> NULL.  */
23314     case 838: value = 839; break;	/* frinti --> frinti.  */
23315     case 839: return NULL;		/* frinti --> NULL.  */
23316     case 803: value = 804; break;	/* fcmp --> fcmp.  */
23317     case 804: return NULL;		/* fcmp --> NULL.  */
23318     case 805: value = 806; break;	/* fcmpe --> fcmpe.  */
23319     case 806: return NULL;		/* fcmpe --> NULL.  */
23320     case 807: value = 808; break;	/* fcmp --> fcmp.  */
23321     case 808: return NULL;		/* fcmp --> NULL.  */
23322     case 809: value = 810; break;	/* fcmpe --> fcmpe.  */
23323     case 810: return NULL;		/* fcmpe --> NULL.  */
23324     case 866: value = 867; break;	/* fmov --> fmov.  */
23325     case 867: return NULL;		/* fmov --> NULL.  */
23326     case 840: value = 841; break;	/* fmul --> fmul.  */
23327     case 841: return NULL;		/* fmul --> NULL.  */
23328     case 856: value = 857; break;	/* fnmul --> fnmul.  */
23329     case 857: return NULL;		/* fnmul --> NULL.  */
23330     case 848: value = 849; break;	/* fmax --> fmax.  */
23331     case 849: return NULL;		/* fmax --> NULL.  */
23332     case 844: value = 845; break;	/* fadd --> fadd.  */
23333     case 845: return NULL;		/* fadd --> NULL.  */
23334     case 852: value = 853; break;	/* fmaxnm --> fmaxnm.  */
23335     case 853: return NULL;		/* fmaxnm --> NULL.  */
23336     case 842: value = 843; break;	/* fdiv --> fdiv.  */
23337     case 843: return NULL;		/* fdiv --> NULL.  */
23338     case 850: value = 851; break;	/* fmin --> fmin.  */
23339     case 851: return NULL;		/* fmin --> NULL.  */
23340     case 846: value = 847; break;	/* fsub --> fsub.  */
23341     case 847: return NULL;		/* fsub --> NULL.  */
23342     case 854: value = 855; break;	/* fminnm --> fminnm.  */
23343     case 855: return NULL;		/* fminnm --> NULL.  */
23344     case 799: value = 800; break;	/* fccmp --> fccmp.  */
23345     case 800: return NULL;		/* fccmp --> NULL.  */
23346     case 801: value = 802; break;	/* fccmpe --> fccmpe.  */
23347     case 802: return NULL;		/* fccmpe --> NULL.  */
23348     case 868: value = 869; break;	/* fcsel --> fcsel.  */
23349     case 869: return NULL;		/* fcsel --> NULL.  */
23350     case 133: value = 374; break;	/* movi --> sshr.  */
23351     case 374: value = 376; break;	/* sshr --> srshr.  */
23352     case 376: return NULL;		/* srshr --> NULL.  */
23353     case 141: value = 396; break;	/* mvni --> ushr.  */
23354     case 396: value = 398; break;	/* ushr --> urshr.  */
23355     case 398: value = 400; break;	/* urshr --> sri.  */
23356     case 400: value = 402; break;	/* sri --> sqshlu.  */
23357     case 402: return NULL;		/* sqshlu --> NULL.  */
23358     case 134: value = 375; break;	/* orr --> ssra.  */
23359     case 375: value = 377; break;	/* ssra --> srsra.  */
23360     case 377: value = 378; break;	/* srsra --> shl.  */
23361     case 378: value = 379; break;	/* shl --> sqshl.  */
23362     case 379: return NULL;		/* sqshl --> NULL.  */
23363     case 142: value = 397; break;	/* bic --> usra.  */
23364     case 397: value = 399; break;	/* usra --> ursra.  */
23365     case 399: value = 401; break;	/* ursra --> sli.  */
23366     case 401: value = 403; break;	/* sli --> uqshl.  */
23367     case 403: return NULL;		/* uqshl --> NULL.  */
23368     case 858: value = 859; break;	/* fmadd --> fmadd.  */
23369     case 859: return NULL;		/* fmadd --> NULL.  */
23370     case 862: value = 863; break;	/* fnmadd --> fnmadd.  */
23371     case 863: return NULL;		/* fnmadd --> NULL.  */
23372     case 135: value = 380; break;	/* movi --> shrn.  */
23373     case 380: value = 381; break;	/* shrn --> shrn2.  */
23374     case 381: value = 388; break;	/* shrn2 --> sshll.  */
23375     case 388: value = 390; break;	/* sshll --> sshll2.  */
23376     case 390: return NULL;		/* sshll2 --> NULL.  */
23377     case 143: value = 404; break;	/* mvni --> sqshrun.  */
23378     case 404: value = 405; break;	/* sqshrun --> sqshrun2.  */
23379     case 405: value = 412; break;	/* sqshrun2 --> ushll.  */
23380     case 412: value = 414; break;	/* ushll --> ushll2.  */
23381     case 414: return NULL;		/* ushll2 --> NULL.  */
23382     case 136: value = 384; break;	/* orr --> sqshrn.  */
23383     case 384: value = 385; break;	/* sqshrn --> sqshrn2.  */
23384     case 385: return NULL;		/* sqshrn2 --> NULL.  */
23385     case 144: value = 408; break;	/* bic --> uqshrn.  */
23386     case 408: value = 409; break;	/* uqshrn --> uqshrn2.  */
23387     case 409: return NULL;		/* uqshrn2 --> NULL.  */
23388     case 138: value = 392; break;	/* movi --> scvtf.  */
23389     case 392: value = 393; break;	/* scvtf --> scvtf.  */
23390     case 393: return NULL;		/* scvtf --> NULL.  */
23391     case 146: value = 147; break;	/* movi --> movi.  */
23392     case 147: value = 416; break;	/* movi --> ucvtf.  */
23393     case 416: value = 417; break;	/* ucvtf --> ucvtf.  */
23394     case 417: return NULL;		/* ucvtf --> NULL.  */
23395     case 140: value = 394; break;	/* fmov --> fcvtzs.  */
23396     case 394: value = 395; break;	/* fcvtzs --> fcvtzs.  */
23397     case 395: return NULL;		/* fcvtzs --> NULL.  */
23398     case 418: value = 419; break;	/* fcvtzu --> fcvtzu.  */
23399     case 419: return NULL;		/* fcvtzu --> NULL.  */
23400     case 860: value = 861; break;	/* fmsub --> fmsub.  */
23401     case 861: return NULL;		/* fmsub --> NULL.  */
23402     case 864: value = 865; break;	/* fnmsub --> fnmsub.  */
23403     case 865: return NULL;		/* fnmsub --> NULL.  */
23404     case 598: value = 599; break;	/* scvtf --> scvtf.  */
23405     case 599: return NULL;		/* scvtf --> NULL.  */
23406     case 600: value = 601; break;	/* fcvtzs --> fcvtzs.  */
23407     case 601: return NULL;		/* fcvtzs --> NULL.  */
23408     case 614: value = 615; break;	/* ucvtf --> ucvtf.  */
23409     case 615: return NULL;		/* ucvtf --> NULL.  */
23410     case 616: value = 617; break;	/* fcvtzu --> fcvtzu.  */
23411     case 617: return NULL;		/* fcvtzu --> NULL.  */
23412     default: return NULL;
23413     }
23414 
23415   return aarch64_opcode_table + value;
23416 }
23417 
23418 const aarch64_opcode *
23419 aarch64_find_alias_opcode (const aarch64_opcode *opcode)
23420 {
23421   /* Use the index as the key to locate the alias opcode.  */
23422   int key = opcode - aarch64_opcode_table;
23423   int value;
23424   switch (key)
23425     {
23426     case 2: value = 3; break;	/* sbc --> ngc.  */
23427     case 4: value = 5; break;	/* sbcs --> ngcs.  */
23428     case 7: value = 8; break;	/* adds --> cmn.  */
23429     case 10: value = 11; break;	/* subs --> cmp.  */
23430     case 12: value = 13; break;	/* add --> mov.  */
23431     case 14: value = 15; break;	/* adds --> cmn.  */
23432     case 17: value = 18; break;	/* subs --> cmp.  */
23433     case 22: value = 23; break;	/* adds --> cmn.  */
23434     case 24: value = 25; break;	/* sub --> neg.  */
23435     case 26: value = 27; break;	/* subs --> cmp.  */
23436     case 152: value = 153; break;	/* umov --> mov.  */
23437     case 154: value = 155; break;	/* ins --> mov.  */
23438     case 156: value = 157; break;	/* ins --> mov.  */
23439     case 242: value = 243; break;	/* not --> mvn.  */
23440     case 317: value = 318; break;	/* orr --> mov.  */
23441     case 388: value = 389; break;	/* sshll --> sxtl.  */
23442     case 390: value = 391; break;	/* sshll2 --> sxtl2.  */
23443     case 412: value = 413; break;	/* ushll --> uxtl.  */
23444     case 414: value = 415; break;	/* ushll2 --> uxtl2.  */
23445     case 535: value = 536; break;	/* dup --> mov.  */
23446     case 618: value = 623; break;	/* sbfm --> sxtw.  */
23447     case 625: value = 627; break;	/* bfm --> bfc.  */
23448     case 629: value = 633; break;	/* ubfm --> uxth.  */
23449     case 663: value = 665; break;	/* csinc --> cset.  */
23450     case 666: value = 668; break;	/* csinv --> csetm.  */
23451     case 669: value = 670; break;	/* csneg --> cneg.  */
23452     case 688: value = 688; break;	/* rev --> rev.  */
23453     case 713: value = 714; break;	/* lslv --> lsl.  */
23454     case 715: value = 716; break;	/* lsrv --> lsr.  */
23455     case 717: value = 718; break;	/* asrv --> asr.  */
23456     case 719: value = 720; break;	/* rorv --> ror.  */
23457     case 722: value = 723; break;	/* subps --> cmpp.  */
23458     case 735: value = 736; break;	/* madd --> mul.  */
23459     case 737: value = 738; break;	/* msub --> mneg.  */
23460     case 739: value = 740; break;	/* smaddl --> smull.  */
23461     case 741: value = 742; break;	/* smsubl --> smnegl.  */
23462     case 744: value = 745; break;	/* umaddl --> umull.  */
23463     case 746: value = 747; break;	/* umsubl --> umnegl.  */
23464     case 758: value = 759; break;	/* extr --> ror.  */
23465     case 991: value = 992; break;	/* and --> bic.  */
23466     case 993: value = 994; break;	/* orr --> mov.  */
23467     case 996: value = 997; break;	/* ands --> tst.  */
23468     case 1000: value = 1002; break;	/* orr --> uxtw.  */
23469     case 1003: value = 1004; break;	/* orn --> mvn.  */
23470     case 1007: value = 1008; break;	/* ands --> tst.  */
23471     case 1038: value = 1134; break;	/* ldaddb --> staddb.  */
23472     case 1039: value = 1135; break;	/* ldaddh --> staddh.  */
23473     case 1040: value = 1136; break;	/* ldadd --> stadd.  */
23474     case 1042: value = 1137; break;	/* ldaddlb --> staddlb.  */
23475     case 1045: value = 1138; break;	/* ldaddlh --> staddlh.  */
23476     case 1048: value = 1139; break;	/* ldaddl --> staddl.  */
23477     case 1050: value = 1140; break;	/* ldclrb --> stclrb.  */
23478     case 1051: value = 1141; break;	/* ldclrh --> stclrh.  */
23479     case 1052: value = 1142; break;	/* ldclr --> stclr.  */
23480     case 1054: value = 1143; break;	/* ldclrlb --> stclrlb.  */
23481     case 1057: value = 1144; break;	/* ldclrlh --> stclrlh.  */
23482     case 1060: value = 1145; break;	/* ldclrl --> stclrl.  */
23483     case 1062: value = 1146; break;	/* ldeorb --> steorb.  */
23484     case 1063: value = 1147; break;	/* ldeorh --> steorh.  */
23485     case 1064: value = 1148; break;	/* ldeor --> steor.  */
23486     case 1066: value = 1149; break;	/* ldeorlb --> steorlb.  */
23487     case 1069: value = 1150; break;	/* ldeorlh --> steorlh.  */
23488     case 1072: value = 1151; break;	/* ldeorl --> steorl.  */
23489     case 1074: value = 1152; break;	/* ldsetb --> stsetb.  */
23490     case 1075: value = 1153; break;	/* ldseth --> stseth.  */
23491     case 1076: value = 1154; break;	/* ldset --> stset.  */
23492     case 1078: value = 1155; break;	/* ldsetlb --> stsetlb.  */
23493     case 1081: value = 1156; break;	/* ldsetlh --> stsetlh.  */
23494     case 1084: value = 1157; break;	/* ldsetl --> stsetl.  */
23495     case 1086: value = 1158; break;	/* ldsmaxb --> stsmaxb.  */
23496     case 1087: value = 1159; break;	/* ldsmaxh --> stsmaxh.  */
23497     case 1088: value = 1160; break;	/* ldsmax --> stsmax.  */
23498     case 1090: value = 1161; break;	/* ldsmaxlb --> stsmaxlb.  */
23499     case 1093: value = 1162; break;	/* ldsmaxlh --> stsmaxlh.  */
23500     case 1096: value = 1163; break;	/* ldsmaxl --> stsmaxl.  */
23501     case 1098: value = 1164; break;	/* ldsminb --> stsminb.  */
23502     case 1099: value = 1165; break;	/* ldsminh --> stsminh.  */
23503     case 1100: value = 1166; break;	/* ldsmin --> stsmin.  */
23504     case 1102: value = 1167; break;	/* ldsminlb --> stsminlb.  */
23505     case 1105: value = 1168; break;	/* ldsminlh --> stsminlh.  */
23506     case 1108: value = 1169; break;	/* ldsminl --> stsminl.  */
23507     case 1110: value = 1170; break;	/* ldumaxb --> stumaxb.  */
23508     case 1111: value = 1171; break;	/* ldumaxh --> stumaxh.  */
23509     case 1112: value = 1172; break;	/* ldumax --> stumax.  */
23510     case 1114: value = 1173; break;	/* ldumaxlb --> stumaxlb.  */
23511     case 1117: value = 1174; break;	/* ldumaxlh --> stumaxlh.  */
23512     case 1120: value = 1175; break;	/* ldumaxl --> stumaxl.  */
23513     case 1122: value = 1176; break;	/* lduminb --> stuminb.  */
23514     case 1123: value = 1177; break;	/* lduminh --> stuminh.  */
23515     case 1124: value = 1178; break;	/* ldumin --> stumin.  */
23516     case 1126: value = 1179; break;	/* lduminlb --> stuminlb.  */
23517     case 1129: value = 1180; break;	/* lduminlh --> stuminlh.  */
23518     case 1132: value = 1181; break;	/* lduminl --> stuminl.  */
23519     case 1182: value = 1183; break;	/* movn --> mov.  */
23520     case 1184: value = 1185; break;	/* movz --> mov.  */
23521     case 1194: value = 1239; break;	/* hint --> autibsp.  */
23522     case 1213: value = 1216; break;	/* dsb --> pssbb.  */
23523     case 1220: value = 1227; break;	/* sys --> cpp.  */
23524     case 1287: value = 2037; break;	/* and --> bic.  */
23525     case 1289: value = 1270; break;	/* and --> mov.  */
23526     case 1290: value = 1274; break;	/* ands --> movs.  */
23527     case 1325: value = 2038; break;	/* cmpge --> cmple.  */
23528     case 1328: value = 2041; break;	/* cmpgt --> cmplt.  */
23529     case 1330: value = 2039; break;	/* cmphi --> cmplo.  */
23530     case 1333: value = 2040; break;	/* cmphs --> cmpls.  */
23531     case 1355: value = 1267; break;	/* cpy --> mov.  */
23532     case 1356: value = 1269; break;	/* cpy --> mov.  */
23533     case 1357: value = 2048; break;	/* cpy --> fmov.  */
23534     case 1369: value = 1262; break;	/* dup --> mov.  */
23535     case 1370: value = 1264; break;	/* dup --> mov.  */
23536     case 1371: value = 2047; break;	/* dup --> fmov.  */
23537     case 1372: value = 1265; break;	/* dupm --> mov.  */
23538     case 1374: value = 2042; break;	/* eor --> eon.  */
23539     case 1376: value = 1275; break;	/* eor --> not.  */
23540     case 1377: value = 1276; break;	/* eors --> nots.  */
23541     case 1382: value = 2043; break;	/* facge --> facle.  */
23542     case 1383: value = 2044; break;	/* facgt --> faclt.  */
23543     case 1396: value = 2045; break;	/* fcmge --> fcmle.  */
23544     case 1398: value = 2046; break;	/* fcmgt --> fcmlt.  */
23545     case 1404: value = 1259; break;	/* fcpy --> fmov.  */
23546     case 1427: value = 1258; break;	/* fdup --> fmov.  */
23547     case 1758: value = 1260; break;	/* orr --> mov.  */
23548     case 1759: value = 2049; break;	/* orr --> orn.  */
23549     case 1761: value = 1263; break;	/* orr --> mov.  */
23550     case 1762: value = 1273; break;	/* orrs --> movs.  */
23551     case 1824: value = 1268; break;	/* sel --> mov.  */
23552     case 1825: value = 1271; break;	/* sel --> mov.  */
23553     default: return NULL;
23554     }
23555 
23556   return aarch64_opcode_table + value;
23557 }
23558 
23559 const aarch64_opcode *
23560 aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)
23561 {
23562   /* Use the index as the key to locate the next opcode.  */
23563   int key = opcode - aarch64_opcode_table;
23564   int value;
23565   switch (key)
23566     {
23567     case 3: value = 2; break;	/* ngc --> sbc.  */
23568     case 5: value = 4; break;	/* ngcs --> sbcs.  */
23569     case 8: value = 7; break;	/* cmn --> adds.  */
23570     case 11: value = 10; break;	/* cmp --> subs.  */
23571     case 13: value = 12; break;	/* mov --> add.  */
23572     case 15: value = 14; break;	/* cmn --> adds.  */
23573     case 18: value = 17; break;	/* cmp --> subs.  */
23574     case 23: value = 22; break;	/* cmn --> adds.  */
23575     case 25: value = 24; break;	/* neg --> sub.  */
23576     case 27: value = 28; break;	/* cmp --> negs.  */
23577     case 28: value = 26; break;	/* negs --> subs.  */
23578     case 153: value = 152; break;	/* mov --> umov.  */
23579     case 155: value = 154; break;	/* mov --> ins.  */
23580     case 157: value = 156; break;	/* mov --> ins.  */
23581     case 243: value = 242; break;	/* mvn --> not.  */
23582     case 318: value = 317; break;	/* mov --> orr.  */
23583     case 389: value = 388; break;	/* sxtl --> sshll.  */
23584     case 391: value = 390; break;	/* sxtl2 --> sshll2.  */
23585     case 413: value = 412; break;	/* uxtl --> ushll.  */
23586     case 415: value = 414; break;	/* uxtl2 --> ushll2.  */
23587     case 536: value = 535; break;	/* mov --> dup.  */
23588     case 623: value = 622; break;	/* sxtw --> sxth.  */
23589     case 622: value = 621; break;	/* sxth --> sxtb.  */
23590     case 621: value = 624; break;	/* sxtb --> asr.  */
23591     case 624: value = 620; break;	/* asr --> sbfx.  */
23592     case 620: value = 619; break;	/* sbfx --> sbfiz.  */
23593     case 619: value = 618; break;	/* sbfiz --> sbfm.  */
23594     case 627: value = 628; break;	/* bfc --> bfxil.  */
23595     case 628: value = 626; break;	/* bfxil --> bfi.  */
23596     case 626: value = 625; break;	/* bfi --> bfm.  */
23597     case 633: value = 632; break;	/* uxth --> uxtb.  */
23598     case 632: value = 635; break;	/* uxtb --> lsr.  */
23599     case 635: value = 634; break;	/* lsr --> lsl.  */
23600     case 634: value = 631; break;	/* lsl --> ubfx.  */
23601     case 631: value = 630; break;	/* ubfx --> ubfiz.  */
23602     case 630: value = 629; break;	/* ubfiz --> ubfm.  */
23603     case 665: value = 664; break;	/* cset --> cinc.  */
23604     case 664: value = 663; break;	/* cinc --> csinc.  */
23605     case 668: value = 667; break;	/* csetm --> cinv.  */
23606     case 667: value = 666; break;	/* cinv --> csinv.  */
23607     case 670: value = 669; break;	/* cneg --> csneg.  */
23608     case 688: value = 689; break;	/* rev --> rev64.  */
23609     case 714: value = 713; break;	/* lsl --> lslv.  */
23610     case 716: value = 715; break;	/* lsr --> lsrv.  */
23611     case 718: value = 717; break;	/* asr --> asrv.  */
23612     case 720: value = 719; break;	/* ror --> rorv.  */
23613     case 723: value = 722; break;	/* cmpp --> subps.  */
23614     case 736: value = 735; break;	/* mul --> madd.  */
23615     case 738: value = 737; break;	/* mneg --> msub.  */
23616     case 740: value = 739; break;	/* smull --> smaddl.  */
23617     case 742: value = 741; break;	/* smnegl --> smsubl.  */
23618     case 745: value = 744; break;	/* umull --> umaddl.  */
23619     case 747: value = 746; break;	/* umnegl --> umsubl.  */
23620     case 759: value = 758; break;	/* ror --> extr.  */
23621     case 992: value = 991; break;	/* bic --> and.  */
23622     case 994: value = 993; break;	/* mov --> orr.  */
23623     case 997: value = 996; break;	/* tst --> ands.  */
23624     case 1002: value = 1001; break;	/* uxtw --> mov.  */
23625     case 1001: value = 1000; break;	/* mov --> orr.  */
23626     case 1004: value = 1003; break;	/* mvn --> orn.  */
23627     case 1008: value = 1007; break;	/* tst --> ands.  */
23628     case 1134: value = 1038; break;	/* staddb --> ldaddb.  */
23629     case 1135: value = 1039; break;	/* staddh --> ldaddh.  */
23630     case 1136: value = 1040; break;	/* stadd --> ldadd.  */
23631     case 1137: value = 1042; break;	/* staddlb --> ldaddlb.  */
23632     case 1138: value = 1045; break;	/* staddlh --> ldaddlh.  */
23633     case 1139: value = 1048; break;	/* staddl --> ldaddl.  */
23634     case 1140: value = 1050; break;	/* stclrb --> ldclrb.  */
23635     case 1141: value = 1051; break;	/* stclrh --> ldclrh.  */
23636     case 1142: value = 1052; break;	/* stclr --> ldclr.  */
23637     case 1143: value = 1054; break;	/* stclrlb --> ldclrlb.  */
23638     case 1144: value = 1057; break;	/* stclrlh --> ldclrlh.  */
23639     case 1145: value = 1060; break;	/* stclrl --> ldclrl.  */
23640     case 1146: value = 1062; break;	/* steorb --> ldeorb.  */
23641     case 1147: value = 1063; break;	/* steorh --> ldeorh.  */
23642     case 1148: value = 1064; break;	/* steor --> ldeor.  */
23643     case 1149: value = 1066; break;	/* steorlb --> ldeorlb.  */
23644     case 1150: value = 1069; break;	/* steorlh --> ldeorlh.  */
23645     case 1151: value = 1072; break;	/* steorl --> ldeorl.  */
23646     case 1152: value = 1074; break;	/* stsetb --> ldsetb.  */
23647     case 1153: value = 1075; break;	/* stseth --> ldseth.  */
23648     case 1154: value = 1076; break;	/* stset --> ldset.  */
23649     case 1155: value = 1078; break;	/* stsetlb --> ldsetlb.  */
23650     case 1156: value = 1081; break;	/* stsetlh --> ldsetlh.  */
23651     case 1157: value = 1084; break;	/* stsetl --> ldsetl.  */
23652     case 1158: value = 1086; break;	/* stsmaxb --> ldsmaxb.  */
23653     case 1159: value = 1087; break;	/* stsmaxh --> ldsmaxh.  */
23654     case 1160: value = 1088; break;	/* stsmax --> ldsmax.  */
23655     case 1161: value = 1090; break;	/* stsmaxlb --> ldsmaxlb.  */
23656     case 1162: value = 1093; break;	/* stsmaxlh --> ldsmaxlh.  */
23657     case 1163: value = 1096; break;	/* stsmaxl --> ldsmaxl.  */
23658     case 1164: value = 1098; break;	/* stsminb --> ldsminb.  */
23659     case 1165: value = 1099; break;	/* stsminh --> ldsminh.  */
23660     case 1166: value = 1100; break;	/* stsmin --> ldsmin.  */
23661     case 1167: value = 1102; break;	/* stsminlb --> ldsminlb.  */
23662     case 1168: value = 1105; break;	/* stsminlh --> ldsminlh.  */
23663     case 1169: value = 1108; break;	/* stsminl --> ldsminl.  */
23664     case 1170: value = 1110; break;	/* stumaxb --> ldumaxb.  */
23665     case 1171: value = 1111; break;	/* stumaxh --> ldumaxh.  */
23666     case 1172: value = 1112; break;	/* stumax --> ldumax.  */
23667     case 1173: value = 1114; break;	/* stumaxlb --> ldumaxlb.  */
23668     case 1174: value = 1117; break;	/* stumaxlh --> ldumaxlh.  */
23669     case 1175: value = 1120; break;	/* stumaxl --> ldumaxl.  */
23670     case 1176: value = 1122; break;	/* stuminb --> lduminb.  */
23671     case 1177: value = 1123; break;	/* stuminh --> lduminh.  */
23672     case 1178: value = 1124; break;	/* stumin --> ldumin.  */
23673     case 1179: value = 1126; break;	/* stuminlb --> lduminlb.  */
23674     case 1180: value = 1129; break;	/* stuminlh --> lduminlh.  */
23675     case 1181: value = 1132; break;	/* stuminl --> lduminl.  */
23676     case 1183: value = 1182; break;	/* mov --> movn.  */
23677     case 1185: value = 1184; break;	/* mov --> movz.  */
23678     case 1239: value = 1238; break;	/* autibsp --> autibz.  */
23679     case 1238: value = 1237; break;	/* autibz --> autiasp.  */
23680     case 1237: value = 1236; break;	/* autiasp --> autiaz.  */
23681     case 1236: value = 1235; break;	/* autiaz --> pacibsp.  */
23682     case 1235: value = 1234; break;	/* pacibsp --> pacibz.  */
23683     case 1234: value = 1233; break;	/* pacibz --> paciasp.  */
23684     case 1233: value = 1232; break;	/* paciasp --> paciaz.  */
23685     case 1232: value = 1211; break;	/* paciaz --> tsb.  */
23686     case 1211: value = 1210; break;	/* tsb --> psb.  */
23687     case 1210: value = 1209; break;	/* psb --> esb.  */
23688     case 1209: value = 1208; break;	/* esb --> autib1716.  */
23689     case 1208: value = 1207; break;	/* autib1716 --> autia1716.  */
23690     case 1207: value = 1206; break;	/* autia1716 --> pacib1716.  */
23691     case 1206: value = 1205; break;	/* pacib1716 --> pacia1716.  */
23692     case 1205: value = 1204; break;	/* pacia1716 --> xpaclri.  */
23693     case 1204: value = 1202; break;	/* xpaclri --> sevl.  */
23694     case 1202: value = 1201; break;	/* sevl --> sev.  */
23695     case 1201: value = 1200; break;	/* sev --> wfi.  */
23696     case 1200: value = 1199; break;	/* wfi --> wfe.  */
23697     case 1199: value = 1198; break;	/* wfe --> yield.  */
23698     case 1198: value = 1197; break;	/* yield --> bti.  */
23699     case 1197: value = 1196; break;	/* bti --> csdb.  */
23700     case 1196: value = 1195; break;	/* csdb --> nop.  */
23701     case 1195: value = 1194; break;	/* nop --> hint.  */
23702     case 1216: value = 1215; break;	/* pssbb --> ssbb.  */
23703     case 1215: value = 1214; break;	/* ssbb --> dfb.  */
23704     case 1214: value = 1213; break;	/* dfb --> dsb.  */
23705     case 1227: value = 1226; break;	/* cpp --> dvp.  */
23706     case 1226: value = 1225; break;	/* dvp --> cfp.  */
23707     case 1225: value = 1224; break;	/* cfp --> tlbi.  */
23708     case 1224: value = 1223; break;	/* tlbi --> ic.  */
23709     case 1223: value = 1222; break;	/* ic --> dc.  */
23710     case 1222: value = 1221; break;	/* dc --> at.  */
23711     case 1221: value = 1220; break;	/* at --> sys.  */
23712     case 2037: value = 1287; break;	/* bic --> and.  */
23713     case 1270: value = 1289; break;	/* mov --> and.  */
23714     case 1274: value = 1290; break;	/* movs --> ands.  */
23715     case 2038: value = 1325; break;	/* cmple --> cmpge.  */
23716     case 2041: value = 1328; break;	/* cmplt --> cmpgt.  */
23717     case 2039: value = 1330; break;	/* cmplo --> cmphi.  */
23718     case 2040: value = 1333; break;	/* cmpls --> cmphs.  */
23719     case 1267: value = 1355; break;	/* mov --> cpy.  */
23720     case 1269: value = 1356; break;	/* mov --> cpy.  */
23721     case 2048: value = 1272; break;	/* fmov --> mov.  */
23722     case 1272: value = 1357; break;	/* mov --> cpy.  */
23723     case 1262: value = 1369; break;	/* mov --> dup.  */
23724     case 1264: value = 1261; break;	/* mov --> mov.  */
23725     case 1261: value = 1370; break;	/* mov --> dup.  */
23726     case 2047: value = 1266; break;	/* fmov --> mov.  */
23727     case 1266: value = 1371; break;	/* mov --> dup.  */
23728     case 1265: value = 1372; break;	/* mov --> dupm.  */
23729     case 2042: value = 1374; break;	/* eon --> eor.  */
23730     case 1275: value = 1376; break;	/* not --> eor.  */
23731     case 1276: value = 1377; break;	/* nots --> eors.  */
23732     case 2043: value = 1382; break;	/* facle --> facge.  */
23733     case 2044: value = 1383; break;	/* faclt --> facgt.  */
23734     case 2045: value = 1396; break;	/* fcmle --> fcmge.  */
23735     case 2046: value = 1398; break;	/* fcmlt --> fcmgt.  */
23736     case 1259: value = 1404; break;	/* fmov --> fcpy.  */
23737     case 1258: value = 1427; break;	/* fmov --> fdup.  */
23738     case 1260: value = 1758; break;	/* mov --> orr.  */
23739     case 2049: value = 1759; break;	/* orn --> orr.  */
23740     case 1263: value = 1761; break;	/* mov --> orr.  */
23741     case 1273: value = 1762; break;	/* movs --> orrs.  */
23742     case 1268: value = 1824; break;	/* mov --> sel.  */
23743     case 1271: value = 1825; break;	/* mov --> sel.  */
23744     default: return NULL;
23745     }
23746 
23747   return aarch64_opcode_table + value;
23748 }
23749 
23750 bfd_boolean
23751 aarch64_extract_operand (const aarch64_operand *self,
23752 			   aarch64_opnd_info *info,
23753 			   aarch64_insn code, const aarch64_inst *inst,
23754 			   aarch64_operand_error *errors)
23755 {
23756   /* Use the index as the key.  */
23757   int key = self - aarch64_operands;
23758   switch (key)
23759     {
23760     case 1:
23761     case 2:
23762     case 3:
23763     case 4:
23764     case 5:
23765     case 6:
23766     case 7:
23767     case 8:
23768     case 10:
23769     case 11:
23770     case 12:
23771     case 16:
23772     case 17:
23773     case 18:
23774     case 19:
23775     case 21:
23776     case 22:
23777     case 23:
23778     case 24:
23779     case 25:
23780     case 26:
23781     case 27:
23782     case 28:
23783     case 29:
23784     case 30:
23785     case 164:
23786     case 165:
23787     case 166:
23788     case 167:
23789     case 168:
23790     case 169:
23791     case 170:
23792     case 171:
23793     case 172:
23794     case 173:
23795     case 188:
23796     case 189:
23797     case 190:
23798     case 191:
23799     case 192:
23800     case 193:
23801     case 194:
23802     case 195:
23803     case 196:
23804     case 202:
23805     case 205:
23806       return aarch64_ext_regno (self, info, code, inst, errors);
23807     case 9:
23808       return aarch64_ext_regrt_sysins (self, info, code, inst, errors);
23809     case 13:
23810       return aarch64_ext_regno_pair (self, info, code, inst, errors);
23811     case 14:
23812       return aarch64_ext_reg_extended (self, info, code, inst, errors);
23813     case 15:
23814       return aarch64_ext_reg_shifted (self, info, code, inst, errors);
23815     case 20:
23816       return aarch64_ext_ft (self, info, code, inst, errors);
23817     case 31:
23818     case 32:
23819     case 33:
23820     case 34:
23821     case 208:
23822       return aarch64_ext_reglane (self, info, code, inst, errors);
23823     case 35:
23824       return aarch64_ext_reglist (self, info, code, inst, errors);
23825     case 36:
23826       return aarch64_ext_ldst_reglist (self, info, code, inst, errors);
23827     case 37:
23828       return aarch64_ext_ldst_reglist_r (self, info, code, inst, errors);
23829     case 38:
23830       return aarch64_ext_ldst_elemlist (self, info, code, inst, errors);
23831     case 39:
23832     case 40:
23833     case 41:
23834     case 42:
23835     case 52:
23836     case 53:
23837     case 54:
23838     case 55:
23839     case 56:
23840     case 57:
23841     case 58:
23842     case 59:
23843     case 60:
23844     case 61:
23845     case 62:
23846     case 63:
23847     case 64:
23848     case 65:
23849     case 66:
23850     case 67:
23851     case 68:
23852     case 79:
23853     case 80:
23854     case 81:
23855     case 82:
23856     case 83:
23857     case 161:
23858     case 163:
23859     case 180:
23860     case 181:
23861     case 182:
23862     case 183:
23863     case 184:
23864     case 185:
23865     case 186:
23866     case 187:
23867     case 207:
23868       return aarch64_ext_imm (self, info, code, inst, errors);
23869     case 43:
23870     case 44:
23871       return aarch64_ext_advsimd_imm_shift (self, info, code, inst, errors);
23872     case 45:
23873     case 46:
23874     case 47:
23875       return aarch64_ext_advsimd_imm_modified (self, info, code, inst, errors);
23876     case 48:
23877       return aarch64_ext_shll_imm (self, info, code, inst, errors);
23878     case 51:
23879     case 151:
23880       return aarch64_ext_fpimm (self, info, code, inst, errors);
23881     case 69:
23882     case 159:
23883       return aarch64_ext_limm (self, info, code, inst, errors);
23884     case 70:
23885       return aarch64_ext_aimm (self, info, code, inst, errors);
23886     case 71:
23887       return aarch64_ext_imm_half (self, info, code, inst, errors);
23888     case 72:
23889       return aarch64_ext_fbits (self, info, code, inst, errors);
23890     case 74:
23891     case 75:
23892     case 156:
23893       return aarch64_ext_imm_rotate2 (self, info, code, inst, errors);
23894     case 76:
23895     case 155:
23896     case 157:
23897       return aarch64_ext_imm_rotate1 (self, info, code, inst, errors);
23898     case 77:
23899     case 78:
23900       return aarch64_ext_cond (self, info, code, inst, errors);
23901     case 84:
23902     case 93:
23903       return aarch64_ext_addr_simple (self, info, code, inst, errors);
23904     case 85:
23905       return aarch64_ext_addr_regoff (self, info, code, inst, errors);
23906     case 86:
23907     case 87:
23908     case 88:
23909     case 90:
23910     case 92:
23911       return aarch64_ext_addr_simm (self, info, code, inst, errors);
23912     case 89:
23913       return aarch64_ext_addr_simm10 (self, info, code, inst, errors);
23914     case 91:
23915       return aarch64_ext_addr_uimm12 (self, info, code, inst, errors);
23916     case 94:
23917       return aarch64_ext_addr_offset (self, info, code, inst, errors);
23918     case 95:
23919       return aarch64_ext_simd_addr_post (self, info, code, inst, errors);
23920     case 96:
23921       return aarch64_ext_sysreg (self, info, code, inst, errors);
23922     case 97:
23923       return aarch64_ext_pstatefield (self, info, code, inst, errors);
23924     case 98:
23925     case 99:
23926     case 100:
23927     case 101:
23928     case 102:
23929       return aarch64_ext_sysins_op (self, info, code, inst, errors);
23930     case 103:
23931     case 104:
23932       return aarch64_ext_barrier (self, info, code, inst, errors);
23933     case 105:
23934       return aarch64_ext_prfop (self, info, code, inst, errors);
23935     case 106:
23936       return aarch64_ext_none (self, info, code, inst, errors);
23937     case 107:
23938       return aarch64_ext_hint (self, info, code, inst, errors);
23939     case 108:
23940     case 109:
23941       return aarch64_ext_sve_addr_ri_s4 (self, info, code, inst, errors);
23942     case 110:
23943     case 111:
23944     case 112:
23945     case 113:
23946       return aarch64_ext_sve_addr_ri_s4xvl (self, info, code, inst, errors);
23947     case 114:
23948       return aarch64_ext_sve_addr_ri_s6xvl (self, info, code, inst, errors);
23949     case 115:
23950       return aarch64_ext_sve_addr_ri_s9xvl (self, info, code, inst, errors);
23951     case 116:
23952     case 117:
23953     case 118:
23954     case 119:
23955       return aarch64_ext_sve_addr_ri_u6 (self, info, code, inst, errors);
23956     case 120:
23957     case 121:
23958     case 122:
23959     case 123:
23960     case 124:
23961     case 125:
23962     case 126:
23963     case 127:
23964     case 128:
23965     case 129:
23966     case 130:
23967     case 131:
23968     case 132:
23969     case 133:
23970       return aarch64_ext_sve_addr_rr_lsl (self, info, code, inst, errors);
23971     case 134:
23972     case 135:
23973     case 136:
23974     case 137:
23975     case 138:
23976     case 139:
23977     case 140:
23978     case 141:
23979       return aarch64_ext_sve_addr_rz_xtw (self, info, code, inst, errors);
23980     case 142:
23981     case 143:
23982     case 144:
23983     case 145:
23984       return aarch64_ext_sve_addr_zi_u5 (self, info, code, inst, errors);
23985     case 146:
23986       return aarch64_ext_sve_addr_zz_lsl (self, info, code, inst, errors);
23987     case 147:
23988       return aarch64_ext_sve_addr_zz_sxtw (self, info, code, inst, errors);
23989     case 148:
23990       return aarch64_ext_sve_addr_zz_uxtw (self, info, code, inst, errors);
23991     case 149:
23992       return aarch64_ext_sve_aimm (self, info, code, inst, errors);
23993     case 150:
23994       return aarch64_ext_sve_asimm (self, info, code, inst, errors);
23995     case 152:
23996       return aarch64_ext_sve_float_half_one (self, info, code, inst, errors);
23997     case 153:
23998       return aarch64_ext_sve_float_half_two (self, info, code, inst, errors);
23999     case 154:
24000       return aarch64_ext_sve_float_zero_one (self, info, code, inst, errors);
24001     case 158:
24002       return aarch64_ext_inv_limm (self, info, code, inst, errors);
24003     case 160:
24004       return aarch64_ext_sve_limm_mov (self, info, code, inst, errors);
24005     case 162:
24006       return aarch64_ext_sve_scale (self, info, code, inst, errors);
24007     case 174:
24008     case 175:
24009     case 176:
24010       return aarch64_ext_sve_shlimm (self, info, code, inst, errors);
24011     case 177:
24012     case 178:
24013     case 179:
24014       return aarch64_ext_sve_shrimm (self, info, code, inst, errors);
24015     case 197:
24016     case 198:
24017     case 199:
24018     case 200:
24019     case 201:
24020       return aarch64_ext_sve_quad_index (self, info, code, inst, errors);
24021     case 203:
24022       return aarch64_ext_sve_index (self, info, code, inst, errors);
24023     case 204:
24024     case 206:
24025       return aarch64_ext_sve_reglist (self, info, code, inst, errors);
24026     default: assert (0); abort ();
24027     }
24028 }
24029