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