aarch64-dis-2.c revision 1.7
1/* This file is automatically generated by aarch64-gen.  Do not edit!  */
2/* Copyright (C) 2012-2020 Free Software Foundation, Inc.
3   Contributed by ARM Ltd.
4
5   This file is part of the GNU opcodes library.
6
7   This library is free software; you can redistribute it and/or modify
8   it under the terms of the GNU General Public License as published by
9   the Free Software Foundation; either version 3, or (at your option)
10   any later version.
11
12   It is distributed in the hope that it will be useful, but WITHOUT
13   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
15   License for more details.
16
17   You should have received a copy of the GNU General Public License
18   along with this program; see the file COPYING3. If not,
19   see <http://www.gnu.org/licenses/>.  */
20
21#include "sysdep.h"
22#include "aarch64-dis.h"
23
24/* Called by aarch64_opcode_lookup.  */
25
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 1186;
44                    }
45                  else
46                    {
47                      /* 33222222222211111111110000000000
48                         10987654321098765432109876543210
49                         1xxx0000xxxxxxxxxxxxxxxxxxxxxxxx
50                         adrp.  */
51                      return 1187;
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 936;
119                                            }
120                                          else
121                                            {
122                                              /* 33222222222211111111110000000000
123                                                 10987654321098765432109876543210
124                                                 0100100x000xxxxx0xxxxxxxxxxxxxxx
125                                                 stxrh.  */
126                                              return 942;
127                                            }
128                                        }
129                                      else
130                                        {
131                                          /* 33222222222211111111110000000000
132                                             10987654321098765432109876543210
133                                             1x00100x000xxxxx0xxxxxxxxxxxxxxx
134                                             stxr.  */
135                                          return 948;
136                                        }
137                                    }
138                                  else
139                                    {
140                                      if (((word >> 31) & 0x1) == 0)
141                                        {
142                                          /* 33222222222211111111110000000000
143                                             10987654321098765432109876543210
144                                             0x00100x001xxxxx0xxxxxxxxxxxxxxx
145                                             casp.  */
146                                          return 1021;
147                                        }
148                                      else
149                                        {
150                                          /* 33222222222211111111110000000000
151                                             10987654321098765432109876543210
152                                             1x00100x001xxxxx0xxxxxxxxxxxxxxx
153                                             stxp.  */
154                                          return 950;
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 937;
171                                            }
172                                          else
173                                            {
174                                              /* 33222222222211111111110000000000
175                                                 10987654321098765432109876543210
176                                                 0100100x000xxxxx1xxxxxxxxxxxxxxx
177                                                 stlxrh.  */
178                                              return 943;
179                                            }
180                                        }
181                                      else
182                                        {
183                                          /* 33222222222211111111110000000000
184                                             10987654321098765432109876543210
185                                             1x00100x000xxxxx1xxxxxxxxxxxxxxx
186                                             stlxr.  */
187                                          return 949;
188                                        }
189                                    }
190                                  else
191                                    {
192                                      if (((word >> 31) & 0x1) == 0)
193                                        {
194                                          /* 33222222222211111111110000000000
195                                             10987654321098765432109876543210
196                                             0x00100x001xxxxx1xxxxxxxxxxxxxxx
197                                             caspl.  */
198                                          return 1023;
199                                        }
200                                      else
201                                        {
202                                          /* 33222222222211111111110000000000
203                                             10987654321098765432109876543210
204                                             1x00100x001xxxxx1xxxxxxxxxxxxxxx
205                                             stlxp.  */
206                                          return 951;
207                                        }
208                                    }
209                                }
210                            }
211                          else
212                            {
213                              if (((word >> 30) & 0x1) == 0)
214                                {
215                                  /* 33222222222211111111110000000000
216                                     10987654321098765432109876543210
217                                     x010100x00xxxxxxxxxxxxxxxxxxxxxx
218                                     stnp.  */
219                                  return 970;
220                                }
221                              else
222                                {
223                                  /* 33222222222211111111110000000000
224                                     10987654321098765432109876543210
225                                     x110100x00xxxxxxxxxxxxxxxxxxxxxx
226                                     stgp.  */
227                                  return 979;
228                                }
229                            }
230                        }
231                      else
232                        {
233                          if (((word >> 29) & 0x1) == 0)
234                            {
235                              if (((word >> 15) & 0x1) == 0)
236                                {
237                                  if (((word >> 21) & 0x1) == 0)
238                                    {
239                                      if (((word >> 31) & 0x1) == 0)
240                                        {
241                                          /* 33222222222211111111110000000000
242                                             10987654321098765432109876543210
243                                             0x00100x100xxxxx0xxxxxxxxxxxxxxx
244                                             stllrb.  */
245                                          return 968;
246                                        }
247                                      else
248                                        {
249                                          /* 33222222222211111111110000000000
250                                             10987654321098765432109876543210
251                                             1x00100x100xxxxx0xxxxxxxxxxxxxxx
252                                             stllr.  */
253                                          return 967;
254                                        }
255                                    }
256                                  else
257                                    {
258                                      if (((word >> 31) & 0x1) == 0)
259                                        {
260                                          if (((word >> 30) & 0x1) == 0)
261                                            {
262                                              /* 33222222222211111111110000000000
263                                                 10987654321098765432109876543210
264                                                 0000100x101xxxxx0xxxxxxxxxxxxxxx
265                                                 casb.  */
266                                              return 1009;
267                                            }
268                                          else
269                                            {
270                                              /* 33222222222211111111110000000000
271                                                 10987654321098765432109876543210
272                                                 0100100x101xxxxx0xxxxxxxxxxxxxxx
273                                                 cash.  */
274                                              return 1010;
275                                            }
276                                        }
277                                      else
278                                        {
279                                          /* 33222222222211111111110000000000
280                                             10987654321098765432109876543210
281                                             1x00100x101xxxxx0xxxxxxxxxxxxxxx
282                                             cas.  */
283                                          return 1011;
284                                        }
285                                    }
286                                }
287                              else
288                                {
289                                  if (((word >> 21) & 0x1) == 0)
290                                    {
291                                      if (((word >> 31) & 0x1) == 0)
292                                        {
293                                          if (((word >> 30) & 0x1) == 0)
294                                            {
295                                              /* 33222222222211111111110000000000
296                                                 10987654321098765432109876543210
297                                                 0000100x100xxxxx1xxxxxxxxxxxxxxx
298                                                 stlrb.  */
299                                              return 940;
300                                            }
301                                          else
302                                            {
303                                              /* 33222222222211111111110000000000
304                                                 10987654321098765432109876543210
305                                                 0100100x100xxxxx1xxxxxxxxxxxxxxx
306                                                 stlrh.  */
307                                              return 946;
308                                            }
309                                        }
310                                      else
311                                        {
312                                          /* 33222222222211111111110000000000
313                                             10987654321098765432109876543210
314                                             1x00100x100xxxxx1xxxxxxxxxxxxxxx
315                                             stlr.  */
316                                          return 956;
317                                        }
318                                    }
319                                  else
320                                    {
321                                      if (((word >> 31) & 0x1) == 0)
322                                        {
323                                          if (((word >> 30) & 0x1) == 0)
324                                            {
325                                              /* 33222222222211111111110000000000
326                                                 10987654321098765432109876543210
327                                                 0000100x101xxxxx1xxxxxxxxxxxxxxx
328                                                 caslb.  */
329                                              return 1013;
330                                            }
331                                          else
332                                            {
333                                              /* 33222222222211111111110000000000
334                                                 10987654321098765432109876543210
335                                                 0100100x101xxxxx1xxxxxxxxxxxxxxx
336                                                 caslh.  */
337                                              return 1016;
338                                            }
339                                        }
340                                      else
341                                        {
342                                          /* 33222222222211111111110000000000
343                                             10987654321098765432109876543210
344                                             1x00100x101xxxxx1xxxxxxxxxxxxxxx
345                                             casl.  */
346                                          return 1019;
347                                        }
348                                    }
349                                }
350                            }
351                          else
352                            {
353                              if (((word >> 30) & 0x1) == 0)
354                                {
355                                  /* 33222222222211111111110000000000
356                                     10987654321098765432109876543210
357                                     x010100x10xxxxxxxxxxxxxxxxxxxxxx
358                                     stp.  */
359                                  return 980;
360                                }
361                              else
362                                {
363                                  /* 33222222222211111111110000000000
364                                     10987654321098765432109876543210
365                                     x110100x10xxxxxxxxxxxxxxxxxxxxxx
366                                     stgp.  */
367                                  return 985;
368                                }
369                            }
370                        }
371                    }
372                  else
373                    {
374                      if (((word >> 23) & 0x1) == 0)
375                        {
376                          if (((word >> 29) & 0x1) == 0)
377                            {
378                              if (((word >> 15) & 0x1) == 0)
379                                {
380                                  if (((word >> 21) & 0x1) == 0)
381                                    {
382                                      if (((word >> 31) & 0x1) == 0)
383                                        {
384                                          if (((word >> 30) & 0x1) == 0)
385                                            {
386                                              /* 33222222222211111111110000000000
387                                                 10987654321098765432109876543210
388                                                 0000100x010xxxxx0xxxxxxxxxxxxxxx
389                                                 ldxrb.  */
390                                              return 938;
391                                            }
392                                          else
393                                            {
394                                              /* 33222222222211111111110000000000
395                                                 10987654321098765432109876543210
396                                                 0100100x010xxxxx0xxxxxxxxxxxxxxx
397                                                 ldxrh.  */
398                                              return 944;
399                                            }
400                                        }
401                                      else
402                                        {
403                                          /* 33222222222211111111110000000000
404                                             10987654321098765432109876543210
405                                             1x00100x010xxxxx0xxxxxxxxxxxxxxx
406                                             ldxr.  */
407                                          return 952;
408                                        }
409                                    }
410                                  else
411                                    {
412                                      if (((word >> 31) & 0x1) == 0)
413                                        {
414                                          /* 33222222222211111111110000000000
415                                             10987654321098765432109876543210
416                                             0x00100x011xxxxx0xxxxxxxxxxxxxxx
417                                             caspa.  */
418                                          return 1022;
419                                        }
420                                      else
421                                        {
422                                          /* 33222222222211111111110000000000
423                                             10987654321098765432109876543210
424                                             1x00100x011xxxxx0xxxxxxxxxxxxxxx
425                                             ldxp.  */
426                                          return 954;
427                                        }
428                                    }
429                                }
430                              else
431                                {
432                                  if (((word >> 21) & 0x1) == 0)
433                                    {
434                                      if (((word >> 31) & 0x1) == 0)
435                                        {
436                                          if (((word >> 30) & 0x1) == 0)
437                                            {
438                                              /* 33222222222211111111110000000000
439                                                 10987654321098765432109876543210
440                                                 0000100x010xxxxx1xxxxxxxxxxxxxxx
441                                                 ldaxrb.  */
442                                              return 939;
443                                            }
444                                          else
445                                            {
446                                              /* 33222222222211111111110000000000
447                                                 10987654321098765432109876543210
448                                                 0100100x010xxxxx1xxxxxxxxxxxxxxx
449                                                 ldaxrh.  */
450                                              return 945;
451                                            }
452                                        }
453                                      else
454                                        {
455                                          /* 33222222222211111111110000000000
456                                             10987654321098765432109876543210
457                                             1x00100x010xxxxx1xxxxxxxxxxxxxxx
458                                             ldaxr.  */
459                                          return 953;
460                                        }
461                                    }
462                                  else
463                                    {
464                                      if (((word >> 31) & 0x1) == 0)
465                                        {
466                                          /* 33222222222211111111110000000000
467                                             10987654321098765432109876543210
468                                             0x00100x011xxxxx1xxxxxxxxxxxxxxx
469                                             caspal.  */
470                                          return 1024;
471                                        }
472                                      else
473                                        {
474                                          /* 33222222222211111111110000000000
475                                             10987654321098765432109876543210
476                                             1x00100x011xxxxx1xxxxxxxxxxxxxxx
477                                             ldaxp.  */
478                                          return 955;
479                                        }
480                                    }
481                                }
482                            }
483                          else
484                            {
485                              if (((word >> 30) & 0x1) == 0)
486                                {
487                                  /* 33222222222211111111110000000000
488                                     10987654321098765432109876543210
489                                     x010100x01xxxxxxxxxxxxxxxxxxxxxx
490                                     ldnp.  */
491                                  return 971;
492                                }
493                              else
494                                {
495                                  /* 33222222222211111111110000000000
496                                     10987654321098765432109876543210
497                                     x110100x01xxxxxxxxxxxxxxxxxxxxxx
498                                     ldpsw.  */
499                                  return 978;
500                                }
501                            }
502                        }
503                      else
504                        {
505                          if (((word >> 29) & 0x1) == 0)
506                            {
507                              if (((word >> 15) & 0x1) == 0)
508                                {
509                                  if (((word >> 21) & 0x1) == 0)
510                                    {
511                                      if (((word >> 31) & 0x1) == 0)
512                                        {
513                                          if (((word >> 30) & 0x1) == 0)
514                                            {
515                                              /* 33222222222211111111110000000000
516                                                 10987654321098765432109876543210
517                                                 0000100x110xxxxx0xxxxxxxxxxxxxxx
518                                                 ldlarb.  */
519                                              return 965;
520                                            }
521                                          else
522                                            {
523                                              /* 33222222222211111111110000000000
524                                                 10987654321098765432109876543210
525                                                 0100100x110xxxxx0xxxxxxxxxxxxxxx
526                                                 ldlarh.  */
527                                              return 966;
528                                            }
529                                        }
530                                      else
531                                        {
532                                          /* 33222222222211111111110000000000
533                                             10987654321098765432109876543210
534                                             1x00100x110xxxxx0xxxxxxxxxxxxxxx
535                                             ldlar.  */
536                                          return 964;
537                                        }
538                                    }
539                                  else
540                                    {
541                                      if (((word >> 31) & 0x1) == 0)
542                                        {
543                                          if (((word >> 30) & 0x1) == 0)
544                                            {
545                                              /* 33222222222211111111110000000000
546                                                 10987654321098765432109876543210
547                                                 0000100x111xxxxx0xxxxxxxxxxxxxxx
548                                                 casab.  */
549                                              return 1012;
550                                            }
551                                          else
552                                            {
553                                              /* 33222222222211111111110000000000
554                                                 10987654321098765432109876543210
555                                                 0100100x111xxxxx0xxxxxxxxxxxxxxx
556                                                 casah.  */
557                                              return 1015;
558                                            }
559                                        }
560                                      else
561                                        {
562                                          /* 33222222222211111111110000000000
563                                             10987654321098765432109876543210
564                                             1x00100x111xxxxx0xxxxxxxxxxxxxxx
565                                             casa.  */
566                                          return 1018;
567                                        }
568                                    }
569                                }
570                              else
571                                {
572                                  if (((word >> 21) & 0x1) == 0)
573                                    {
574                                      if (((word >> 31) & 0x1) == 0)
575                                        {
576                                          if (((word >> 30) & 0x1) == 0)
577                                            {
578                                              /* 33222222222211111111110000000000
579                                                 10987654321098765432109876543210
580                                                 0000100x110xxxxx1xxxxxxxxxxxxxxx
581                                                 ldarb.  */
582                                              return 941;
583                                            }
584                                          else
585                                            {
586                                              /* 33222222222211111111110000000000
587                                                 10987654321098765432109876543210
588                                                 0100100x110xxxxx1xxxxxxxxxxxxxxx
589                                                 ldarh.  */
590                                              return 947;
591                                            }
592                                        }
593                                      else
594                                        {
595                                          /* 33222222222211111111110000000000
596                                             10987654321098765432109876543210
597                                             1x00100x110xxxxx1xxxxxxxxxxxxxxx
598                                             ldar.  */
599                                          return 957;
600                                        }
601                                    }
602                                  else
603                                    {
604                                      if (((word >> 31) & 0x1) == 0)
605                                        {
606                                          if (((word >> 30) & 0x1) == 0)
607                                            {
608                                              /* 33222222222211111111110000000000
609                                                 10987654321098765432109876543210
610                                                 0000100x111xxxxx1xxxxxxxxxxxxxxx
611                                                 casalb.  */
612                                              return 1014;
613                                            }
614                                          else
615                                            {
616                                              /* 33222222222211111111110000000000
617                                                 10987654321098765432109876543210
618                                                 0100100x111xxxxx1xxxxxxxxxxxxxxx
619                                                 casalh.  */
620                                              return 1017;
621                                            }
622                                        }
623                                      else
624                                        {
625                                          /* 33222222222211111111110000000000
626                                             10987654321098765432109876543210
627                                             1x00100x111xxxxx1xxxxxxxxxxxxxxx
628                                             casal.  */
629                                          return 1020;
630                                        }
631                                    }
632                                }
633                            }
634                          else
635                            {
636                              if (((word >> 30) & 0x1) == 0)
637                                {
638                                  /* 33222222222211111111110000000000
639                                     10987654321098765432109876543210
640                                     x010100x11xxxxxxxxxxxxxxxxxxxxxx
641                                     ldp.  */
642                                  return 981;
643                                }
644                              else
645                                {
646                                  /* 33222222222211111111110000000000
647                                     10987654321098765432109876543210
648                                     x110100x11xxxxxxxxxxxxxxxxxxxxxx
649                                     ldpsw.  */
650                                  return 984;
651                                }
652                            }
653                        }
654                    }
655                }
656              else
657                {
658                  if (((word >> 24) & 0x1) == 0)
659                    {
660                      if (((word >> 29) & 0x1) == 0)
661                        {
662                          if (((word >> 31) & 0x1) == 0)
663                            {
664                              /* 33222222222211111111110000000000
665                                 10987654321098765432109876543210
666                                 0x011000xxxxxxxxxxxxxxxxxxxxxxxx
667                                 ldr.  */
668                              return 986;
669                            }
670                          else
671                            {
672                              if (((word >> 30) & 0x1) == 0)
673                                {
674                                  /* 33222222222211111111110000000000
675                                     10987654321098765432109876543210
676                                     10011000xxxxxxxxxxxxxxxxxxxxxxxx
677                                     ldrsw.  */
678                                  return 988;
679                                }
680                              else
681                                {
682                                  /* 33222222222211111111110000000000
683                                     10987654321098765432109876543210
684                                     11011000xxxxxxxxxxxxxxxxxxxxxxxx
685                                     prfm.  */
686                                  return 989;
687                                }
688                            }
689                        }
690                      else
691                        {
692                          if (((word >> 10) & 0x1) == 0)
693                            {
694                              if (((word >> 11) & 0x1) == 0)
695                                {
696                                  if (((word >> 21) & 0x1) == 0)
697                                    {
698                                      if (((word >> 23) & 0x1) == 0)
699                                        {
700                                          if (((word >> 22) & 0x1) == 0)
701                                            {
702                                              if (((word >> 31) & 0x1) == 0)
703                                                {
704                                                  if (((word >> 30) & 0x1) == 0)
705                                                    {
706                                                      /* 33222222222211111111110000000000
707                                                         10987654321098765432109876543210
708                                                         00111000000xxxxxxxxx00xxxxxxxxxx
709                                                         sturb.  */
710                                                      return 921;
711                                                    }
712                                                  else
713                                                    {
714                                                      /* 33222222222211111111110000000000
715                                                         10987654321098765432109876543210
716                                                         01111000000xxxxxxxxx00xxxxxxxxxx
717                                                         sturh.  */
718                                                      return 926;
719                                                    }
720                                                }
721                                              else
722                                                {
723                                                  /* 33222222222211111111110000000000
724                                                     10987654321098765432109876543210
725                                                     1x111000000xxxxxxxxx00xxxxxxxxxx
726                                                     stur.  */
727                                                  return 929;
728                                                }
729                                            }
730                                          else
731                                            {
732                                              if (((word >> 31) & 0x1) == 0)
733                                                {
734                                                  if (((word >> 30) & 0x1) == 0)
735                                                    {
736                                                      /* 33222222222211111111110000000000
737                                                         10987654321098765432109876543210
738                                                         00111000010xxxxxxxxx00xxxxxxxxxx
739                                                         ldurb.  */
740                                                      return 922;
741                                                    }
742                                                  else
743                                                    {
744                                                      /* 33222222222211111111110000000000
745                                                         10987654321098765432109876543210
746                                                         01111000010xxxxxxxxx00xxxxxxxxxx
747                                                         ldurh.  */
748                                                      return 927;
749                                                    }
750                                                }
751                                              else
752                                                {
753                                                  /* 33222222222211111111110000000000
754                                                     10987654321098765432109876543210
755                                                     1x111000010xxxxxxxxx00xxxxxxxxxx
756                                                     ldur.  */
757                                                  return 930;
758                                                }
759                                            }
760                                        }
761                                      else
762                                        {
763                                          if (((word >> 30) & 0x1) == 0)
764                                            {
765                                              if (((word >> 31) & 0x1) == 0)
766                                                {
767                                                  /* 33222222222211111111110000000000
768                                                     10987654321098765432109876543210
769                                                     001110001x0xxxxxxxxx00xxxxxxxxxx
770                                                     ldursb.  */
771                                                  return 923;
772                                                }
773                                              else
774                                                {
775                                                  /* 33222222222211111111110000000000
776                                                     10987654321098765432109876543210
777                                                     101110001x0xxxxxxxxx00xxxxxxxxxx
778                                                     ldursw.  */
779                                                  return 931;
780                                                }
781                                            }
782                                          else
783                                            {
784                                              if (((word >> 31) & 0x1) == 0)
785                                                {
786                                                  /* 33222222222211111111110000000000
787                                                     10987654321098765432109876543210
788                                                     011110001x0xxxxxxxxx00xxxxxxxxxx
789                                                     ldursh.  */
790                                                  return 928;
791                                                }
792                                              else
793                                                {
794                                                  /* 33222222222211111111110000000000
795                                                     10987654321098765432109876543210
796                                                     111110001x0xxxxxxxxx00xxxxxxxxxx
797                                                     prfum.  */
798                                                  return 932;
799                                                }
800                                            }
801                                        }
802                                    }
803                                  else
804                                    {
805                                      if (((word >> 12) & 0x1) == 0)
806                                        {
807                                          if (((word >> 13) & 0x1) == 0)
808                                            {
809                                              if (((word >> 14) & 0x1) == 0)
810                                                {
811                                                  if (((word >> 15) & 0x1) == 0)
812                                                    {
813                                                      if (((word >> 22) & 0x1) == 0)
814                                                        {
815                                                          if (((word >> 23) & 0x1) == 0)
816                                                            {
817                                                              if (((word >> 31) & 0x1) == 0)
818                                                                {
819                                                                  if (((word >> 30) & 0x1) == 0)
820                                                                    {
821                                                                      /* 33222222222211111111110000000000
822                                                                         10987654321098765432109876543210
823                                                                         00111000001xxxxx000000xxxxxxxxxx
824                                                                         ldaddb.  */
825                                                                      return 1037;
826                                                                    }
827                                                                  else
828                                                                    {
829                                                                      /* 33222222222211111111110000000000
830                                                                         10987654321098765432109876543210
831                                                                         01111000001xxxxx000000xxxxxxxxxx
832                                                                         ldaddh.  */
833                                                                      return 1038;
834                                                                    }
835                                                                }
836                                                              else
837                                                                {
838                                                                  /* 33222222222211111111110000000000
839                                                                     10987654321098765432109876543210
840                                                                     1x111000001xxxxx000000xxxxxxxxxx
841                                                                     ldadd.  */
842                                                                  return 1039;
843                                                                }
844                                                            }
845                                                          else
846                                                            {
847                                                              if (((word >> 31) & 0x1) == 0)
848                                                                {
849                                                                  if (((word >> 30) & 0x1) == 0)
850                                                                    {
851                                                                      /* 33222222222211111111110000000000
852                                                                         10987654321098765432109876543210
853                                                                         00111000101xxxxx000000xxxxxxxxxx
854                                                                         ldaddab.  */
855                                                                      return 1040;
856                                                                    }
857                                                                  else
858                                                                    {
859                                                                      /* 33222222222211111111110000000000
860                                                                         10987654321098765432109876543210
861                                                                         01111000101xxxxx000000xxxxxxxxxx
862                                                                         ldaddah.  */
863                                                                      return 1043;
864                                                                    }
865                                                                }
866                                                              else
867                                                                {
868                                                                  /* 33222222222211111111110000000000
869                                                                     10987654321098765432109876543210
870                                                                     1x111000101xxxxx000000xxxxxxxxxx
871                                                                     ldadda.  */
872                                                                  return 1046;
873                                                                }
874                                                            }
875                                                        }
876                                                      else
877                                                        {
878                                                          if (((word >> 23) & 0x1) == 0)
879                                                            {
880                                                              if (((word >> 31) & 0x1) == 0)
881                                                                {
882                                                                  if (((word >> 30) & 0x1) == 0)
883                                                                    {
884                                                                      /* 33222222222211111111110000000000
885                                                                         10987654321098765432109876543210
886                                                                         00111000011xxxxx000000xxxxxxxxxx
887                                                                         ldaddlb.  */
888                                                                      return 1041;
889                                                                    }
890                                                                  else
891                                                                    {
892                                                                      /* 33222222222211111111110000000000
893                                                                         10987654321098765432109876543210
894                                                                         01111000011xxxxx000000xxxxxxxxxx
895                                                                         ldaddlh.  */
896                                                                      return 1044;
897                                                                    }
898                                                                }
899                                                              else
900                                                                {
901                                                                  /* 33222222222211111111110000000000
902                                                                     10987654321098765432109876543210
903                                                                     1x111000011xxxxx000000xxxxxxxxxx
904                                                                     ldaddl.  */
905                                                                  return 1047;
906                                                                }
907                                                            }
908                                                          else
909                                                            {
910                                                              if (((word >> 31) & 0x1) == 0)
911                                                                {
912                                                                  if (((word >> 30) & 0x1) == 0)
913                                                                    {
914                                                                      /* 33222222222211111111110000000000
915                                                                         10987654321098765432109876543210
916                                                                         00111000111xxxxx000000xxxxxxxxxx
917                                                                         ldaddalb.  */
918                                                                      return 1042;
919                                                                    }
920                                                                  else
921                                                                    {
922                                                                      /* 33222222222211111111110000000000
923                                                                         10987654321098765432109876543210
924                                                                         01111000111xxxxx000000xxxxxxxxxx
925                                                                         ldaddalh.  */
926                                                                      return 1045;
927                                                                    }
928                                                                }
929                                                              else
930                                                                {
931                                                                  /* 33222222222211111111110000000000
932                                                                     10987654321098765432109876543210
933                                                                     1x111000111xxxxx000000xxxxxxxxxx
934                                                                     ldaddal.  */
935                                                                  return 1048;
936                                                                }
937                                                            }
938                                                        }
939                                                    }
940                                                  else
941                                                    {
942                                                      if (((word >> 22) & 0x1) == 0)
943                                                        {
944                                                          if (((word >> 23) & 0x1) == 0)
945                                                            {
946                                                              if (((word >> 31) & 0x1) == 0)
947                                                                {
948                                                                  if (((word >> 30) & 0x1) == 0)
949                                                                    {
950                                                                      /* 33222222222211111111110000000000
951                                                                         10987654321098765432109876543210
952                                                                         00111000001xxxxx100000xxxxxxxxxx
953                                                                         swpb.  */
954                                                                      return 1025;
955                                                                    }
956                                                                  else
957                                                                    {
958                                                                      /* 33222222222211111111110000000000
959                                                                         10987654321098765432109876543210
960                                                                         01111000001xxxxx100000xxxxxxxxxx
961                                                                         swph.  */
962                                                                      return 1026;
963                                                                    }
964                                                                }
965                                                              else
966                                                                {
967                                                                  /* 33222222222211111111110000000000
968                                                                     10987654321098765432109876543210
969                                                                     1x111000001xxxxx100000xxxxxxxxxx
970                                                                     swp.  */
971                                                                  return 1027;
972                                                                }
973                                                            }
974                                                          else
975                                                            {
976                                                              if (((word >> 31) & 0x1) == 0)
977                                                                {
978                                                                  if (((word >> 30) & 0x1) == 0)
979                                                                    {
980                                                                      /* 33222222222211111111110000000000
981                                                                         10987654321098765432109876543210
982                                                                         00111000101xxxxx100000xxxxxxxxxx
983                                                                         swpab.  */
984                                                                      return 1028;
985                                                                    }
986                                                                  else
987                                                                    {
988                                                                      /* 33222222222211111111110000000000
989                                                                         10987654321098765432109876543210
990                                                                         01111000101xxxxx100000xxxxxxxxxx
991                                                                         swpah.  */
992                                                                      return 1031;
993                                                                    }
994                                                                }
995                                                              else
996                                                                {
997                                                                  /* 33222222222211111111110000000000
998                                                                     10987654321098765432109876543210
999                                                                     1x111000101xxxxx100000xxxxxxxxxx
1000                                                                     swpa.  */
1001                                                                  return 1034;
1002                                                                }
1003                                                            }
1004                                                        }
1005                                                      else
1006                                                        {
1007                                                          if (((word >> 23) & 0x1) == 0)
1008                                                            {
1009                                                              if (((word >> 31) & 0x1) == 0)
1010                                                                {
1011                                                                  if (((word >> 30) & 0x1) == 0)
1012                                                                    {
1013                                                                      /* 33222222222211111111110000000000
1014                                                                         10987654321098765432109876543210
1015                                                                         00111000011xxxxx100000xxxxxxxxxx
1016                                                                         swplb.  */
1017                                                                      return 1029;
1018                                                                    }
1019                                                                  else
1020                                                                    {
1021                                                                      /* 33222222222211111111110000000000
1022                                                                         10987654321098765432109876543210
1023                                                                         01111000011xxxxx100000xxxxxxxxxx
1024                                                                         swplh.  */
1025                                                                      return 1032;
1026                                                                    }
1027                                                                }
1028                                                              else
1029                                                                {
1030                                                                  /* 33222222222211111111110000000000
1031                                                                     10987654321098765432109876543210
1032                                                                     1x111000011xxxxx100000xxxxxxxxxx
1033                                                                     swpl.  */
1034                                                                  return 1035;
1035                                                                }
1036                                                            }
1037                                                          else
1038                                                            {
1039                                                              if (((word >> 31) & 0x1) == 0)
1040                                                                {
1041                                                                  if (((word >> 30) & 0x1) == 0)
1042                                                                    {
1043                                                                      /* 33222222222211111111110000000000
1044                                                                         10987654321098765432109876543210
1045                                                                         00111000111xxxxx100000xxxxxxxxxx
1046                                                                         swpalb.  */
1047                                                                      return 1030;
1048                                                                    }
1049                                                                  else
1050                                                                    {
1051                                                                      /* 33222222222211111111110000000000
1052                                                                         10987654321098765432109876543210
1053                                                                         01111000111xxxxx100000xxxxxxxxxx
1054                                                                         swpalh.  */
1055                                                                      return 1033;
1056                                                                    }
1057                                                                }
1058                                                              else
1059                                                                {
1060                                                                  /* 33222222222211111111110000000000
1061                                                                     10987654321098765432109876543210
1062                                                                     1x111000111xxxxx100000xxxxxxxxxx
1063                                                                     swpal.  */
1064                                                                  return 1036;
1065                                                                }
1066                                                            }
1067                                                        }
1068                                                    }
1069                                                }
1070                                              else
1071                                                {
1072                                                  if (((word >> 15) & 0x1) == 0)
1073                                                    {
1074                                                      if (((word >> 22) & 0x1) == 0)
1075                                                        {
1076                                                          if (((word >> 23) & 0x1) == 0)
1077                                                            {
1078                                                              if (((word >> 31) & 0x1) == 0)
1079                                                                {
1080                                                                  if (((word >> 30) & 0x1) == 0)
1081                                                                    {
1082                                                                      /* 33222222222211111111110000000000
1083                                                                         10987654321098765432109876543210
1084                                                                         00111000001xxxxx010000xxxxxxxxxx
1085                                                                         ldsmaxb.  */
1086                                                                      return 1085;
1087                                                                    }
1088                                                                  else
1089                                                                    {
1090                                                                      /* 33222222222211111111110000000000
1091                                                                         10987654321098765432109876543210
1092                                                                         01111000001xxxxx010000xxxxxxxxxx
1093                                                                         ldsmaxh.  */
1094                                                                      return 1086;
1095                                                                    }
1096                                                                }
1097                                                              else
1098                                                                {
1099                                                                  /* 33222222222211111111110000000000
1100                                                                     10987654321098765432109876543210
1101                                                                     1x111000001xxxxx010000xxxxxxxxxx
1102                                                                     ldsmax.  */
1103                                                                  return 1087;
1104                                                                }
1105                                                            }
1106                                                          else
1107                                                            {
1108                                                              if (((word >> 31) & 0x1) == 0)
1109                                                                {
1110                                                                  if (((word >> 30) & 0x1) == 0)
1111                                                                    {
1112                                                                      /* 33222222222211111111110000000000
1113                                                                         10987654321098765432109876543210
1114                                                                         00111000101xxxxx010000xxxxxxxxxx
1115                                                                         ldsmaxab.  */
1116                                                                      return 1088;
1117                                                                    }
1118                                                                  else
1119                                                                    {
1120                                                                      /* 33222222222211111111110000000000
1121                                                                         10987654321098765432109876543210
1122                                                                         01111000101xxxxx010000xxxxxxxxxx
1123                                                                         ldsmaxah.  */
1124                                                                      return 1091;
1125                                                                    }
1126                                                                }
1127                                                              else
1128                                                                {
1129                                                                  /* 33222222222211111111110000000000
1130                                                                     10987654321098765432109876543210
1131                                                                     1x111000101xxxxx010000xxxxxxxxxx
1132                                                                     ldsmaxa.  */
1133                                                                  return 1094;
1134                                                                }
1135                                                            }
1136                                                        }
1137                                                      else
1138                                                        {
1139                                                          if (((word >> 23) & 0x1) == 0)
1140                                                            {
1141                                                              if (((word >> 31) & 0x1) == 0)
1142                                                                {
1143                                                                  if (((word >> 30) & 0x1) == 0)
1144                                                                    {
1145                                                                      /* 33222222222211111111110000000000
1146                                                                         10987654321098765432109876543210
1147                                                                         00111000011xxxxx010000xxxxxxxxxx
1148                                                                         ldsmaxlb.  */
1149                                                                      return 1089;
1150                                                                    }
1151                                                                  else
1152                                                                    {
1153                                                                      /* 33222222222211111111110000000000
1154                                                                         10987654321098765432109876543210
1155                                                                         01111000011xxxxx010000xxxxxxxxxx
1156                                                                         ldsmaxlh.  */
1157                                                                      return 1092;
1158                                                                    }
1159                                                                }
1160                                                              else
1161                                                                {
1162                                                                  /* 33222222222211111111110000000000
1163                                                                     10987654321098765432109876543210
1164                                                                     1x111000011xxxxx010000xxxxxxxxxx
1165                                                                     ldsmaxl.  */
1166                                                                  return 1095;
1167                                                                }
1168                                                            }
1169                                                          else
1170                                                            {
1171                                                              if (((word >> 31) & 0x1) == 0)
1172                                                                {
1173                                                                  if (((word >> 30) & 0x1) == 0)
1174                                                                    {
1175                                                                      /* 33222222222211111111110000000000
1176                                                                         10987654321098765432109876543210
1177                                                                         00111000111xxxxx010000xxxxxxxxxx
1178                                                                         ldsmaxalb.  */
1179                                                                      return 1090;
1180                                                                    }
1181                                                                  else
1182                                                                    {
1183                                                                      /* 33222222222211111111110000000000
1184                                                                         10987654321098765432109876543210
1185                                                                         01111000111xxxxx010000xxxxxxxxxx
1186                                                                         ldsmaxalh.  */
1187                                                                      return 1093;
1188                                                                    }
1189                                                                }
1190                                                              else
1191                                                                {
1192                                                                  /* 33222222222211111111110000000000
1193                                                                     10987654321098765432109876543210
1194                                                                     1x111000111xxxxx010000xxxxxxxxxx
1195                                                                     ldsmaxal.  */
1196                                                                  return 1096;
1197                                                                }
1198                                                            }
1199                                                        }
1200                                                    }
1201                                                  else
1202                                                    {
1203                                                      if (((word >> 31) & 0x1) == 0)
1204                                                        {
1205                                                          if (((word >> 30) & 0x1) == 0)
1206                                                            {
1207                                                              /* 33222222222211111111110000000000
1208                                                                 10987654321098765432109876543210
1209                                                                 00111000xx1xxxxx110000xxxxxxxxxx
1210                                                                 ldaprb.  */
1211                                                              return 958;
1212                                                            }
1213                                                          else
1214                                                            {
1215                                                              /* 33222222222211111111110000000000
1216                                                                 10987654321098765432109876543210
1217                                                                 01111000xx1xxxxx110000xxxxxxxxxx
1218                                                                 ldaprh.  */
1219                                                              return 959;
1220                                                            }
1221                                                        }
1222                                                      else
1223                                                        {
1224                                                          /* 33222222222211111111110000000000
1225                                                             10987654321098765432109876543210
1226                                                             1x111000xx1xxxxx110000xxxxxxxxxx
1227                                                             ldapr.  */
1228                                                          return 960;
1229                                                        }
1230                                                    }
1231                                                }
1232                                            }
1233                                          else
1234                                            {
1235                                              if (((word >> 14) & 0x1) == 0)
1236                                                {
1237                                                  if (((word >> 22) & 0x1) == 0)
1238                                                    {
1239                                                      if (((word >> 23) & 0x1) == 0)
1240                                                        {
1241                                                          if (((word >> 31) & 0x1) == 0)
1242                                                            {
1243                                                              if (((word >> 30) & 0x1) == 0)
1244                                                                {
1245                                                                  /* 33222222222211111111110000000000
1246                                                                     10987654321098765432109876543210
1247                                                                     00111000001xxxxxx01000xxxxxxxxxx
1248                                                                     ldeorb.  */
1249                                                                  return 1061;
1250                                                                }
1251                                                              else
1252                                                                {
1253                                                                  /* 33222222222211111111110000000000
1254                                                                     10987654321098765432109876543210
1255                                                                     01111000001xxxxxx01000xxxxxxxxxx
1256                                                                     ldeorh.  */
1257                                                                  return 1062;
1258                                                                }
1259                                                            }
1260                                                          else
1261                                                            {
1262                                                              /* 33222222222211111111110000000000
1263                                                                 10987654321098765432109876543210
1264                                                                 1x111000001xxxxxx01000xxxxxxxxxx
1265                                                                 ldeor.  */
1266                                                              return 1063;
1267                                                            }
1268                                                        }
1269                                                      else
1270                                                        {
1271                                                          if (((word >> 31) & 0x1) == 0)
1272                                                            {
1273                                                              if (((word >> 30) & 0x1) == 0)
1274                                                                {
1275                                                                  /* 33222222222211111111110000000000
1276                                                                     10987654321098765432109876543210
1277                                                                     00111000101xxxxxx01000xxxxxxxxxx
1278                                                                     ldeorab.  */
1279                                                                  return 1064;
1280                                                                }
1281                                                              else
1282                                                                {
1283                                                                  /* 33222222222211111111110000000000
1284                                                                     10987654321098765432109876543210
1285                                                                     01111000101xxxxxx01000xxxxxxxxxx
1286                                                                     ldeorah.  */
1287                                                                  return 1067;
1288                                                                }
1289                                                            }
1290                                                          else
1291                                                            {
1292                                                              /* 33222222222211111111110000000000
1293                                                                 10987654321098765432109876543210
1294                                                                 1x111000101xxxxxx01000xxxxxxxxxx
1295                                                                 ldeora.  */
1296                                                              return 1070;
1297                                                            }
1298                                                        }
1299                                                    }
1300                                                  else
1301                                                    {
1302                                                      if (((word >> 23) & 0x1) == 0)
1303                                                        {
1304                                                          if (((word >> 31) & 0x1) == 0)
1305                                                            {
1306                                                              if (((word >> 30) & 0x1) == 0)
1307                                                                {
1308                                                                  /* 33222222222211111111110000000000
1309                                                                     10987654321098765432109876543210
1310                                                                     00111000011xxxxxx01000xxxxxxxxxx
1311                                                                     ldeorlb.  */
1312                                                                  return 1065;
1313                                                                }
1314                                                              else
1315                                                                {
1316                                                                  /* 33222222222211111111110000000000
1317                                                                     10987654321098765432109876543210
1318                                                                     01111000011xxxxxx01000xxxxxxxxxx
1319                                                                     ldeorlh.  */
1320                                                                  return 1068;
1321                                                                }
1322                                                            }
1323                                                          else
1324                                                            {
1325                                                              /* 33222222222211111111110000000000
1326                                                                 10987654321098765432109876543210
1327                                                                 1x111000011xxxxxx01000xxxxxxxxxx
1328                                                                 ldeorl.  */
1329                                                              return 1071;
1330                                                            }
1331                                                        }
1332                                                      else
1333                                                        {
1334                                                          if (((word >> 31) & 0x1) == 0)
1335                                                            {
1336                                                              if (((word >> 30) & 0x1) == 0)
1337                                                                {
1338                                                                  /* 33222222222211111111110000000000
1339                                                                     10987654321098765432109876543210
1340                                                                     00111000111xxxxxx01000xxxxxxxxxx
1341                                                                     ldeoralb.  */
1342                                                                  return 1066;
1343                                                                }
1344                                                              else
1345                                                                {
1346                                                                  /* 33222222222211111111110000000000
1347                                                                     10987654321098765432109876543210
1348                                                                     01111000111xxxxxx01000xxxxxxxxxx
1349                                                                     ldeoralh.  */
1350                                                                  return 1069;
1351                                                                }
1352                                                            }
1353                                                          else
1354                                                            {
1355                                                              /* 33222222222211111111110000000000
1356                                                                 10987654321098765432109876543210
1357                                                                 1x111000111xxxxxx01000xxxxxxxxxx
1358                                                                 ldeoral.  */
1359                                                              return 1072;
1360                                                            }
1361                                                        }
1362                                                    }
1363                                                }
1364                                              else
1365                                                {
1366                                                  if (((word >> 22) & 0x1) == 0)
1367                                                    {
1368                                                      if (((word >> 23) & 0x1) == 0)
1369                                                        {
1370                                                          if (((word >> 31) & 0x1) == 0)
1371                                                            {
1372                                                              if (((word >> 30) & 0x1) == 0)
1373                                                                {
1374                                                                  /* 33222222222211111111110000000000
1375                                                                     10987654321098765432109876543210
1376                                                                     00111000001xxxxxx11000xxxxxxxxxx
1377                                                                     ldumaxb.  */
1378                                                                  return 1109;
1379                                                                }
1380                                                              else
1381                                                                {
1382                                                                  /* 33222222222211111111110000000000
1383                                                                     10987654321098765432109876543210
1384                                                                     01111000001xxxxxx11000xxxxxxxxxx
1385                                                                     ldumaxh.  */
1386                                                                  return 1110;
1387                                                                }
1388                                                            }
1389                                                          else
1390                                                            {
1391                                                              /* 33222222222211111111110000000000
1392                                                                 10987654321098765432109876543210
1393                                                                 1x111000001xxxxxx11000xxxxxxxxxx
1394                                                                 ldumax.  */
1395                                                              return 1111;
1396                                                            }
1397                                                        }
1398                                                      else
1399                                                        {
1400                                                          if (((word >> 31) & 0x1) == 0)
1401                                                            {
1402                                                              if (((word >> 30) & 0x1) == 0)
1403                                                                {
1404                                                                  /* 33222222222211111111110000000000
1405                                                                     10987654321098765432109876543210
1406                                                                     00111000101xxxxxx11000xxxxxxxxxx
1407                                                                     ldumaxab.  */
1408                                                                  return 1112;
1409                                                                }
1410                                                              else
1411                                                                {
1412                                                                  /* 33222222222211111111110000000000
1413                                                                     10987654321098765432109876543210
1414                                                                     01111000101xxxxxx11000xxxxxxxxxx
1415                                                                     ldumaxah.  */
1416                                                                  return 1115;
1417                                                                }
1418                                                            }
1419                                                          else
1420                                                            {
1421                                                              /* 33222222222211111111110000000000
1422                                                                 10987654321098765432109876543210
1423                                                                 1x111000101xxxxxx11000xxxxxxxxxx
1424                                                                 ldumaxa.  */
1425                                                              return 1118;
1426                                                            }
1427                                                        }
1428                                                    }
1429                                                  else
1430                                                    {
1431                                                      if (((word >> 23) & 0x1) == 0)
1432                                                        {
1433                                                          if (((word >> 31) & 0x1) == 0)
1434                                                            {
1435                                                              if (((word >> 30) & 0x1) == 0)
1436                                                                {
1437                                                                  /* 33222222222211111111110000000000
1438                                                                     10987654321098765432109876543210
1439                                                                     00111000011xxxxxx11000xxxxxxxxxx
1440                                                                     ldumaxlb.  */
1441                                                                  return 1113;
1442                                                                }
1443                                                              else
1444                                                                {
1445                                                                  /* 33222222222211111111110000000000
1446                                                                     10987654321098765432109876543210
1447                                                                     01111000011xxxxxx11000xxxxxxxxxx
1448                                                                     ldumaxlh.  */
1449                                                                  return 1116;
1450                                                                }
1451                                                            }
1452                                                          else
1453                                                            {
1454                                                              /* 33222222222211111111110000000000
1455                                                                 10987654321098765432109876543210
1456                                                                 1x111000011xxxxxx11000xxxxxxxxxx
1457                                                                 ldumaxl.  */
1458                                                              return 1119;
1459                                                            }
1460                                                        }
1461                                                      else
1462                                                        {
1463                                                          if (((word >> 31) & 0x1) == 0)
1464                                                            {
1465                                                              if (((word >> 30) & 0x1) == 0)
1466                                                                {
1467                                                                  /* 33222222222211111111110000000000
1468                                                                     10987654321098765432109876543210
1469                                                                     00111000111xxxxxx11000xxxxxxxxxx
1470                                                                     ldumaxalb.  */
1471                                                                  return 1114;
1472                                                                }
1473                                                              else
1474                                                                {
1475                                                                  /* 33222222222211111111110000000000
1476                                                                     10987654321098765432109876543210
1477                                                                     01111000111xxxxxx11000xxxxxxxxxx
1478                                                                     ldumaxalh.  */
1479                                                                  return 1117;
1480                                                                }
1481                                                            }
1482                                                          else
1483                                                            {
1484                                                              /* 33222222222211111111110000000000
1485                                                                 10987654321098765432109876543210
1486                                                                 1x111000111xxxxxx11000xxxxxxxxxx
1487                                                                 ldumaxal.  */
1488                                                              return 1120;
1489                                                            }
1490                                                        }
1491                                                    }
1492                                                }
1493                                            }
1494                                        }
1495                                      else
1496                                        {
1497                                          if (((word >> 13) & 0x1) == 0)
1498                                            {
1499                                              if (((word >> 14) & 0x1) == 0)
1500                                                {
1501                                                  if (((word >> 22) & 0x1) == 0)
1502                                                    {
1503                                                      if (((word >> 23) & 0x1) == 0)
1504                                                        {
1505                                                          if (((word >> 31) & 0x1) == 0)
1506                                                            {
1507                                                              if (((word >> 30) & 0x1) == 0)
1508                                                                {
1509                                                                  /* 33222222222211111111110000000000
1510                                                                     10987654321098765432109876543210
1511                                                                     00111000001xxxxxx00100xxxxxxxxxx
1512                                                                     ldclrb.  */
1513                                                                  return 1049;
1514                                                                }
1515                                                              else
1516                                                                {
1517                                                                  /* 33222222222211111111110000000000
1518                                                                     10987654321098765432109876543210
1519                                                                     01111000001xxxxxx00100xxxxxxxxxx
1520                                                                     ldclrh.  */
1521                                                                  return 1050;
1522                                                                }
1523                                                            }
1524                                                          else
1525                                                            {
1526                                                              /* 33222222222211111111110000000000
1527                                                                 10987654321098765432109876543210
1528                                                                 1x111000001xxxxxx00100xxxxxxxxxx
1529                                                                 ldclr.  */
1530                                                              return 1051;
1531                                                            }
1532                                                        }
1533                                                      else
1534                                                        {
1535                                                          if (((word >> 31) & 0x1) == 0)
1536                                                            {
1537                                                              if (((word >> 30) & 0x1) == 0)
1538                                                                {
1539                                                                  /* 33222222222211111111110000000000
1540                                                                     10987654321098765432109876543210
1541                                                                     00111000101xxxxxx00100xxxxxxxxxx
1542                                                                     ldclrab.  */
1543                                                                  return 1052;
1544                                                                }
1545                                                              else
1546                                                                {
1547                                                                  /* 33222222222211111111110000000000
1548                                                                     10987654321098765432109876543210
1549                                                                     01111000101xxxxxx00100xxxxxxxxxx
1550                                                                     ldclrah.  */
1551                                                                  return 1055;
1552                                                                }
1553                                                            }
1554                                                          else
1555                                                            {
1556                                                              /* 33222222222211111111110000000000
1557                                                                 10987654321098765432109876543210
1558                                                                 1x111000101xxxxxx00100xxxxxxxxxx
1559                                                                 ldclra.  */
1560                                                              return 1058;
1561                                                            }
1562                                                        }
1563                                                    }
1564                                                  else
1565                                                    {
1566                                                      if (((word >> 23) & 0x1) == 0)
1567                                                        {
1568                                                          if (((word >> 31) & 0x1) == 0)
1569                                                            {
1570                                                              if (((word >> 30) & 0x1) == 0)
1571                                                                {
1572                                                                  /* 33222222222211111111110000000000
1573                                                                     10987654321098765432109876543210
1574                                                                     00111000011xxxxxx00100xxxxxxxxxx
1575                                                                     ldclrlb.  */
1576                                                                  return 1053;
1577                                                                }
1578                                                              else
1579                                                                {
1580                                                                  /* 33222222222211111111110000000000
1581                                                                     10987654321098765432109876543210
1582                                                                     01111000011xxxxxx00100xxxxxxxxxx
1583                                                                     ldclrlh.  */
1584                                                                  return 1056;
1585                                                                }
1586                                                            }
1587                                                          else
1588                                                            {
1589                                                              /* 33222222222211111111110000000000
1590                                                                 10987654321098765432109876543210
1591                                                                 1x111000011xxxxxx00100xxxxxxxxxx
1592                                                                 ldclrl.  */
1593                                                              return 1059;
1594                                                            }
1595                                                        }
1596                                                      else
1597                                                        {
1598                                                          if (((word >> 31) & 0x1) == 0)
1599                                                            {
1600                                                              if (((word >> 30) & 0x1) == 0)
1601                                                                {
1602                                                                  /* 33222222222211111111110000000000
1603                                                                     10987654321098765432109876543210
1604                                                                     00111000111xxxxxx00100xxxxxxxxxx
1605                                                                     ldclralb.  */
1606                                                                  return 1054;
1607                                                                }
1608                                                              else
1609                                                                {
1610                                                                  /* 33222222222211111111110000000000
1611                                                                     10987654321098765432109876543210
1612                                                                     01111000111xxxxxx00100xxxxxxxxxx
1613                                                                     ldclralh.  */
1614                                                                  return 1057;
1615                                                                }
1616                                                            }
1617                                                          else
1618                                                            {
1619                                                              /* 33222222222211111111110000000000
1620                                                                 10987654321098765432109876543210
1621                                                                 1x111000111xxxxxx00100xxxxxxxxxx
1622                                                                 ldclral.  */
1623                                                              return 1060;
1624                                                            }
1625                                                        }
1626                                                    }
1627                                                }
1628                                              else
1629                                                {
1630                                                  if (((word >> 22) & 0x1) == 0)
1631                                                    {
1632                                                      if (((word >> 23) & 0x1) == 0)
1633                                                        {
1634                                                          if (((word >> 31) & 0x1) == 0)
1635                                                            {
1636                                                              if (((word >> 30) & 0x1) == 0)
1637                                                                {
1638                                                                  /* 33222222222211111111110000000000
1639                                                                     10987654321098765432109876543210
1640                                                                     00111000001xxxxxx10100xxxxxxxxxx
1641                                                                     ldsminb.  */
1642                                                                  return 1097;
1643                                                                }
1644                                                              else
1645                                                                {
1646                                                                  /* 33222222222211111111110000000000
1647                                                                     10987654321098765432109876543210
1648                                                                     01111000001xxxxxx10100xxxxxxxxxx
1649                                                                     ldsminh.  */
1650                                                                  return 1098;
1651                                                                }
1652                                                            }
1653                                                          else
1654                                                            {
1655                                                              /* 33222222222211111111110000000000
1656                                                                 10987654321098765432109876543210
1657                                                                 1x111000001xxxxxx10100xxxxxxxxxx
1658                                                                 ldsmin.  */
1659                                                              return 1099;
1660                                                            }
1661                                                        }
1662                                                      else
1663                                                        {
1664                                                          if (((word >> 31) & 0x1) == 0)
1665                                                            {
1666                                                              if (((word >> 30) & 0x1) == 0)
1667                                                                {
1668                                                                  /* 33222222222211111111110000000000
1669                                                                     10987654321098765432109876543210
1670                                                                     00111000101xxxxxx10100xxxxxxxxxx
1671                                                                     ldsminab.  */
1672                                                                  return 1100;
1673                                                                }
1674                                                              else
1675                                                                {
1676                                                                  /* 33222222222211111111110000000000
1677                                                                     10987654321098765432109876543210
1678                                                                     01111000101xxxxxx10100xxxxxxxxxx
1679                                                                     ldsminah.  */
1680                                                                  return 1103;
1681                                                                }
1682                                                            }
1683                                                          else
1684                                                            {
1685                                                              /* 33222222222211111111110000000000
1686                                                                 10987654321098765432109876543210
1687                                                                 1x111000101xxxxxx10100xxxxxxxxxx
1688                                                                 ldsmina.  */
1689                                                              return 1106;
1690                                                            }
1691                                                        }
1692                                                    }
1693                                                  else
1694                                                    {
1695                                                      if (((word >> 23) & 0x1) == 0)
1696                                                        {
1697                                                          if (((word >> 31) & 0x1) == 0)
1698                                                            {
1699                                                              if (((word >> 30) & 0x1) == 0)
1700                                                                {
1701                                                                  /* 33222222222211111111110000000000
1702                                                                     10987654321098765432109876543210
1703                                                                     00111000011xxxxxx10100xxxxxxxxxx
1704                                                                     ldsminlb.  */
1705                                                                  return 1101;
1706                                                                }
1707                                                              else
1708                                                                {
1709                                                                  /* 33222222222211111111110000000000
1710                                                                     10987654321098765432109876543210
1711                                                                     01111000011xxxxxx10100xxxxxxxxxx
1712                                                                     ldsminlh.  */
1713                                                                  return 1104;
1714                                                                }
1715                                                            }
1716                                                          else
1717                                                            {
1718                                                              /* 33222222222211111111110000000000
1719                                                                 10987654321098765432109876543210
1720                                                                 1x111000011xxxxxx10100xxxxxxxxxx
1721                                                                 ldsminl.  */
1722                                                              return 1107;
1723                                                            }
1724                                                        }
1725                                                      else
1726                                                        {
1727                                                          if (((word >> 31) & 0x1) == 0)
1728                                                            {
1729                                                              if (((word >> 30) & 0x1) == 0)
1730                                                                {
1731                                                                  /* 33222222222211111111110000000000
1732                                                                     10987654321098765432109876543210
1733                                                                     00111000111xxxxxx10100xxxxxxxxxx
1734                                                                     ldsminalb.  */
1735                                                                  return 1102;
1736                                                                }
1737                                                              else
1738                                                                {
1739                                                                  /* 33222222222211111111110000000000
1740                                                                     10987654321098765432109876543210
1741                                                                     01111000111xxxxxx10100xxxxxxxxxx
1742                                                                     ldsminalh.  */
1743                                                                  return 1105;
1744                                                                }
1745                                                            }
1746                                                          else
1747                                                            {
1748                                                              /* 33222222222211111111110000000000
1749                                                                 10987654321098765432109876543210
1750                                                                 1x111000111xxxxxx10100xxxxxxxxxx
1751                                                                 ldsminal.  */
1752                                                              return 1108;
1753                                                            }
1754                                                        }
1755                                                    }
1756                                                }
1757                                            }
1758                                          else
1759                                            {
1760                                              if (((word >> 14) & 0x1) == 0)
1761                                                {
1762                                                  if (((word >> 22) & 0x1) == 0)
1763                                                    {
1764                                                      if (((word >> 23) & 0x1) == 0)
1765                                                        {
1766                                                          if (((word >> 31) & 0x1) == 0)
1767                                                            {
1768                                                              if (((word >> 30) & 0x1) == 0)
1769                                                                {
1770                                                                  /* 33222222222211111111110000000000
1771                                                                     10987654321098765432109876543210
1772                                                                     00111000001xxxxxx01100xxxxxxxxxx
1773                                                                     ldsetb.  */
1774                                                                  return 1073;
1775                                                                }
1776                                                              else
1777                                                                {
1778                                                                  /* 33222222222211111111110000000000
1779                                                                     10987654321098765432109876543210
1780                                                                     01111000001xxxxxx01100xxxxxxxxxx
1781                                                                     ldseth.  */
1782                                                                  return 1074;
1783                                                                }
1784                                                            }
1785                                                          else
1786                                                            {
1787                                                              /* 33222222222211111111110000000000
1788                                                                 10987654321098765432109876543210
1789                                                                 1x111000001xxxxxx01100xxxxxxxxxx
1790                                                                 ldset.  */
1791                                                              return 1075;
1792                                                            }
1793                                                        }
1794                                                      else
1795                                                        {
1796                                                          if (((word >> 31) & 0x1) == 0)
1797                                                            {
1798                                                              if (((word >> 30) & 0x1) == 0)
1799                                                                {
1800                                                                  /* 33222222222211111111110000000000
1801                                                                     10987654321098765432109876543210
1802                                                                     00111000101xxxxxx01100xxxxxxxxxx
1803                                                                     ldsetab.  */
1804                                                                  return 1076;
1805                                                                }
1806                                                              else
1807                                                                {
1808                                                                  /* 33222222222211111111110000000000
1809                                                                     10987654321098765432109876543210
1810                                                                     01111000101xxxxxx01100xxxxxxxxxx
1811                                                                     ldsetah.  */
1812                                                                  return 1079;
1813                                                                }
1814                                                            }
1815                                                          else
1816                                                            {
1817                                                              /* 33222222222211111111110000000000
1818                                                                 10987654321098765432109876543210
1819                                                                 1x111000101xxxxxx01100xxxxxxxxxx
1820                                                                 ldseta.  */
1821                                                              return 1082;
1822                                                            }
1823                                                        }
1824                                                    }
1825                                                  else
1826                                                    {
1827                                                      if (((word >> 23) & 0x1) == 0)
1828                                                        {
1829                                                          if (((word >> 31) & 0x1) == 0)
1830                                                            {
1831                                                              if (((word >> 30) & 0x1) == 0)
1832                                                                {
1833                                                                  /* 33222222222211111111110000000000
1834                                                                     10987654321098765432109876543210
1835                                                                     00111000011xxxxxx01100xxxxxxxxxx
1836                                                                     ldsetlb.  */
1837                                                                  return 1077;
1838                                                                }
1839                                                              else
1840                                                                {
1841                                                                  /* 33222222222211111111110000000000
1842                                                                     10987654321098765432109876543210
1843                                                                     01111000011xxxxxx01100xxxxxxxxxx
1844                                                                     ldsetlh.  */
1845                                                                  return 1080;
1846                                                                }
1847                                                            }
1848                                                          else
1849                                                            {
1850                                                              /* 33222222222211111111110000000000
1851                                                                 10987654321098765432109876543210
1852                                                                 1x111000011xxxxxx01100xxxxxxxxxx
1853                                                                 ldsetl.  */
1854                                                              return 1083;
1855                                                            }
1856                                                        }
1857                                                      else
1858                                                        {
1859                                                          if (((word >> 31) & 0x1) == 0)
1860                                                            {
1861                                                              if (((word >> 30) & 0x1) == 0)
1862                                                                {
1863                                                                  /* 33222222222211111111110000000000
1864                                                                     10987654321098765432109876543210
1865                                                                     00111000111xxxxxx01100xxxxxxxxxx
1866                                                                     ldsetalb.  */
1867                                                                  return 1078;
1868                                                                }
1869                                                              else
1870                                                                {
1871                                                                  /* 33222222222211111111110000000000
1872                                                                     10987654321098765432109876543210
1873                                                                     01111000111xxxxxx01100xxxxxxxxxx
1874                                                                     ldsetalh.  */
1875                                                                  return 1081;
1876                                                                }
1877                                                            }
1878                                                          else
1879                                                            {
1880                                                              /* 33222222222211111111110000000000
1881                                                                 10987654321098765432109876543210
1882                                                                 1x111000111xxxxxx01100xxxxxxxxxx
1883                                                                 ldsetal.  */
1884                                                              return 1084;
1885                                                            }
1886                                                        }
1887                                                    }
1888                                                }
1889                                              else
1890                                                {
1891                                                  if (((word >> 22) & 0x1) == 0)
1892                                                    {
1893                                                      if (((word >> 23) & 0x1) == 0)
1894                                                        {
1895                                                          if (((word >> 31) & 0x1) == 0)
1896                                                            {
1897                                                              if (((word >> 30) & 0x1) == 0)
1898                                                                {
1899                                                                  /* 33222222222211111111110000000000
1900                                                                     10987654321098765432109876543210
1901                                                                     00111000001xxxxxx11100xxxxxxxxxx
1902                                                                     lduminb.  */
1903                                                                  return 1121;
1904                                                                }
1905                                                              else
1906                                                                {
1907                                                                  /* 33222222222211111111110000000000
1908                                                                     10987654321098765432109876543210
1909                                                                     01111000001xxxxxx11100xxxxxxxxxx
1910                                                                     lduminh.  */
1911                                                                  return 1122;
1912                                                                }
1913                                                            }
1914                                                          else
1915                                                            {
1916                                                              /* 33222222222211111111110000000000
1917                                                                 10987654321098765432109876543210
1918                                                                 1x111000001xxxxxx11100xxxxxxxxxx
1919                                                                 ldumin.  */
1920                                                              return 1123;
1921                                                            }
1922                                                        }
1923                                                      else
1924                                                        {
1925                                                          if (((word >> 31) & 0x1) == 0)
1926                                                            {
1927                                                              if (((word >> 30) & 0x1) == 0)
1928                                                                {
1929                                                                  /* 33222222222211111111110000000000
1930                                                                     10987654321098765432109876543210
1931                                                                     00111000101xxxxxx11100xxxxxxxxxx
1932                                                                     lduminab.  */
1933                                                                  return 1124;
1934                                                                }
1935                                                              else
1936                                                                {
1937                                                                  /* 33222222222211111111110000000000
1938                                                                     10987654321098765432109876543210
1939                                                                     01111000101xxxxxx11100xxxxxxxxxx
1940                                                                     lduminah.  */
1941                                                                  return 1127;
1942                                                                }
1943                                                            }
1944                                                          else
1945                                                            {
1946                                                              /* 33222222222211111111110000000000
1947                                                                 10987654321098765432109876543210
1948                                                                 1x111000101xxxxxx11100xxxxxxxxxx
1949                                                                 ldumina.  */
1950                                                              return 1130;
1951                                                            }
1952                                                        }
1953                                                    }
1954                                                  else
1955                                                    {
1956                                                      if (((word >> 23) & 0x1) == 0)
1957                                                        {
1958                                                          if (((word >> 31) & 0x1) == 0)
1959                                                            {
1960                                                              if (((word >> 30) & 0x1) == 0)
1961                                                                {
1962                                                                  /* 33222222222211111111110000000000
1963                                                                     10987654321098765432109876543210
1964                                                                     00111000011xxxxxx11100xxxxxxxxxx
1965                                                                     lduminlb.  */
1966                                                                  return 1125;
1967                                                                }
1968                                                              else
1969                                                                {
1970                                                                  /* 33222222222211111111110000000000
1971                                                                     10987654321098765432109876543210
1972                                                                     01111000011xxxxxx11100xxxxxxxxxx
1973                                                                     lduminlh.  */
1974                                                                  return 1128;
1975                                                                }
1976                                                            }
1977                                                          else
1978                                                            {
1979                                                              /* 33222222222211111111110000000000
1980                                                                 10987654321098765432109876543210
1981                                                                 1x111000011xxxxxx11100xxxxxxxxxx
1982                                                                 lduminl.  */
1983                                                              return 1131;
1984                                                            }
1985                                                        }
1986                                                      else
1987                                                        {
1988                                                          if (((word >> 31) & 0x1) == 0)
1989                                                            {
1990                                                              if (((word >> 30) & 0x1) == 0)
1991                                                                {
1992                                                                  /* 33222222222211111111110000000000
1993                                                                     10987654321098765432109876543210
1994                                                                     00111000111xxxxxx11100xxxxxxxxxx
1995                                                                     lduminalb.  */
1996                                                                  return 1126;
1997                                                                }
1998                                                              else
1999                                                                {
2000                                                                  /* 33222222222211111111110000000000
2001                                                                     10987654321098765432109876543210
2002                                                                     01111000111xxxxxx11100xxxxxxxxxx
2003                                                                     lduminalh.  */
2004                                                                  return 1129;
2005                                                                }
2006                                                            }
2007                                                          else
2008                                                            {
2009                                                              /* 33222222222211111111110000000000
2010                                                                 10987654321098765432109876543210
2011                                                                 1x111000111xxxxxx11100xxxxxxxxxx
2012                                                                 lduminal.  */
2013                                                              return 1132;
2014                                                            }
2015                                                        }
2016                                                    }
2017                                                }
2018                                            }
2019                                        }
2020                                    }
2021                                }
2022                              else
2023                                {
2024                                  if (((word >> 21) & 0x1) == 0)
2025                                    {
2026                                      if (((word >> 23) & 0x1) == 0)
2027                                        {
2028                                          if (((word >> 22) & 0x1) == 0)
2029                                            {
2030                                              if (((word >> 31) & 0x1) == 0)
2031                                                {
2032                                                  if (((word >> 30) & 0x1) == 0)
2033                                                    {
2034                                                      /* 33222222222211111111110000000000
2035                                                         10987654321098765432109876543210
2036                                                         00111000000xxxxxxxxx10xxxxxxxxxx
2037                                                         sttrb.  */
2038                                                      return 912;
2039                                                    }
2040                                                  else
2041                                                    {
2042                                                      /* 33222222222211111111110000000000
2043                                                         10987654321098765432109876543210
2044                                                         01111000000xxxxxxxxx10xxxxxxxxxx
2045                                                         sttrh.  */
2046                                                      return 915;
2047                                                    }
2048                                                }
2049                                              else
2050                                                {
2051                                                  /* 33222222222211111111110000000000
2052                                                     10987654321098765432109876543210
2053                                                     1x111000000xxxxxxxxx10xxxxxxxxxx
2054                                                     sttr.  */
2055                                                  return 918;
2056                                                }
2057                                            }
2058                                          else
2059                                            {
2060                                              if (((word >> 31) & 0x1) == 0)
2061                                                {
2062                                                  if (((word >> 30) & 0x1) == 0)
2063                                                    {
2064                                                      /* 33222222222211111111110000000000
2065                                                         10987654321098765432109876543210
2066                                                         00111000010xxxxxxxxx10xxxxxxxxxx
2067                                                         ldtrb.  */
2068                                                      return 913;
2069                                                    }
2070                                                  else
2071                                                    {
2072                                                      /* 33222222222211111111110000000000
2073                                                         10987654321098765432109876543210
2074                                                         01111000010xxxxxxxxx10xxxxxxxxxx
2075                                                         ldtrh.  */
2076                                                      return 916;
2077                                                    }
2078                                                }
2079                                              else
2080                                                {
2081                                                  /* 33222222222211111111110000000000
2082                                                     10987654321098765432109876543210
2083                                                     1x111000010xxxxxxxxx10xxxxxxxxxx
2084                                                     ldtr.  */
2085                                                  return 919;
2086                                                }
2087                                            }
2088                                        }
2089                                      else
2090                                        {
2091                                          if (((word >> 30) & 0x1) == 0)
2092                                            {
2093                                              if (((word >> 31) & 0x1) == 0)
2094                                                {
2095                                                  /* 33222222222211111111110000000000
2096                                                     10987654321098765432109876543210
2097                                                     001110001x0xxxxxxxxx10xxxxxxxxxx
2098                                                     ldtrsb.  */
2099                                                  return 914;
2100                                                }
2101                                              else
2102                                                {
2103                                                  /* 33222222222211111111110000000000
2104                                                     10987654321098765432109876543210
2105                                                     101110001x0xxxxxxxxx10xxxxxxxxxx
2106                                                     ldtrsw.  */
2107                                                  return 920;
2108                                                }
2109                                            }
2110                                          else
2111                                            {
2112                                              /* 33222222222211111111110000000000
2113                                                 10987654321098765432109876543210
2114                                                 x11110001x0xxxxxxxxx10xxxxxxxxxx
2115                                                 ldtrsh.  */
2116                                              return 917;
2117                                            }
2118                                        }
2119                                    }
2120                                  else
2121                                    {
2122                                      if (((word >> 23) & 0x1) == 0)
2123                                        {
2124                                          if (((word >> 22) & 0x1) == 0)
2125                                            {
2126                                              if (((word >> 31) & 0x1) == 0)
2127                                                {
2128                                                  if (((word >> 30) & 0x1) == 0)
2129                                                    {
2130                                                      /* 33222222222211111111110000000000
2131                                                         10987654321098765432109876543210
2132                                                         00111000001xxxxxxxxx10xxxxxxxxxx
2133                                                         strb.  */
2134                                                      return 900;
2135                                                    }
2136                                                  else
2137                                                    {
2138                                                      /* 33222222222211111111110000000000
2139                                                         10987654321098765432109876543210
2140                                                         01111000001xxxxxxxxx10xxxxxxxxxx
2141                                                         strh.  */
2142                                                      return 905;
2143                                                    }
2144                                                }
2145                                              else
2146                                                {
2147                                                  /* 33222222222211111111110000000000
2148                                                     10987654321098765432109876543210
2149                                                     1x111000001xxxxxxxxx10xxxxxxxxxx
2150                                                     str.  */
2151                                                  return 908;
2152                                                }
2153                                            }
2154                                          else
2155                                            {
2156                                              if (((word >> 31) & 0x1) == 0)
2157                                                {
2158                                                  if (((word >> 30) & 0x1) == 0)
2159                                                    {
2160                                                      /* 33222222222211111111110000000000
2161                                                         10987654321098765432109876543210
2162                                                         00111000011xxxxxxxxx10xxxxxxxxxx
2163                                                         ldrb.  */
2164                                                      return 901;
2165                                                    }
2166                                                  else
2167                                                    {
2168                                                      /* 33222222222211111111110000000000
2169                                                         10987654321098765432109876543210
2170                                                         01111000011xxxxxxxxx10xxxxxxxxxx
2171                                                         ldrh.  */
2172                                                      return 906;
2173                                                    }
2174                                                }
2175                                              else
2176                                                {
2177                                                  /* 33222222222211111111110000000000
2178                                                     10987654321098765432109876543210
2179                                                     1x111000011xxxxxxxxx10xxxxxxxxxx
2180                                                     ldr.  */
2181                                                  return 909;
2182                                                }
2183                                            }
2184                                        }
2185                                      else
2186                                        {
2187                                          if (((word >> 30) & 0x1) == 0)
2188                                            {
2189                                              if (((word >> 31) & 0x1) == 0)
2190                                                {
2191                                                  /* 33222222222211111111110000000000
2192                                                     10987654321098765432109876543210
2193                                                     001110001x1xxxxxxxxx10xxxxxxxxxx
2194                                                     ldrsb.  */
2195                                                  return 902;
2196                                                }
2197                                              else
2198                                                {
2199                                                  /* 33222222222211111111110000000000
2200                                                     10987654321098765432109876543210
2201                                                     101110001x1xxxxxxxxx10xxxxxxxxxx
2202                                                     ldrsw.  */
2203                                                  return 910;
2204                                                }
2205                                            }
2206                                          else
2207                                            {
2208                                              if (((word >> 31) & 0x1) == 0)
2209                                                {
2210                                                  /* 33222222222211111111110000000000
2211                                                     10987654321098765432109876543210
2212                                                     011110001x1xxxxxxxxx10xxxxxxxxxx
2213                                                     ldrsh.  */
2214                                                  return 907;
2215                                                }
2216                                              else
2217                                                {
2218                                                  /* 33222222222211111111110000000000
2219                                                     10987654321098765432109876543210
2220                                                     111110001x1xxxxxxxxx10xxxxxxxxxx
2221                                                     prfm.  */
2222                                                  return 911;
2223                                                }
2224                                            }
2225                                        }
2226                                    }
2227                                }
2228                            }
2229                          else
2230                            {
2231                              if (((word >> 21) & 0x1) == 0)
2232                                {
2233                                  if (((word >> 23) & 0x1) == 0)
2234                                    {
2235                                      if (((word >> 22) & 0x1) == 0)
2236                                        {
2237                                          if (((word >> 31) & 0x1) == 0)
2238                                            {
2239                                              if (((word >> 30) & 0x1) == 0)
2240                                                {
2241                                                  /* 33222222222211111111110000000000
2242                                                     10987654321098765432109876543210
2243                                                     00111000000xxxxxxxxxx1xxxxxxxxxx
2244                                                     strb.  */
2245                                                  return 869;
2246                                                }
2247                                              else
2248                                                {
2249                                                  /* 33222222222211111111110000000000
2250                                                     10987654321098765432109876543210
2251                                                     01111000000xxxxxxxxxx1xxxxxxxxxx
2252                                                     strh.  */
2253                                                  return 874;
2254                                                }
2255                                            }
2256                                          else
2257                                            {
2258                                              /* 33222222222211111111110000000000
2259                                                 10987654321098765432109876543210
2260                                                 1x111000000xxxxxxxxxx1xxxxxxxxxx
2261                                                 str.  */
2262                                              return 877;
2263                                            }
2264                                        }
2265                                      else
2266                                        {
2267                                          if (((word >> 31) & 0x1) == 0)
2268                                            {
2269                                              if (((word >> 30) & 0x1) == 0)
2270                                                {
2271                                                  /* 33222222222211111111110000000000
2272                                                     10987654321098765432109876543210
2273                                                     00111000010xxxxxxxxxx1xxxxxxxxxx
2274                                                     ldrb.  */
2275                                                  return 870;
2276                                                }
2277                                              else
2278                                                {
2279                                                  /* 33222222222211111111110000000000
2280                                                     10987654321098765432109876543210
2281                                                     01111000010xxxxxxxxxx1xxxxxxxxxx
2282                                                     ldrh.  */
2283                                                  return 875;
2284                                                }
2285                                            }
2286                                          else
2287                                            {
2288                                              /* 33222222222211111111110000000000
2289                                                 10987654321098765432109876543210
2290                                                 1x111000010xxxxxxxxxx1xxxxxxxxxx
2291                                                 ldr.  */
2292                                              return 878;
2293                                            }
2294                                        }
2295                                    }
2296                                  else
2297                                    {
2298                                      if (((word >> 30) & 0x1) == 0)
2299                                        {
2300                                          if (((word >> 31) & 0x1) == 0)
2301                                            {
2302                                              /* 33222222222211111111110000000000
2303                                                 10987654321098765432109876543210
2304                                                 001110001x0xxxxxxxxxx1xxxxxxxxxx
2305                                                 ldrsb.  */
2306                                              return 871;
2307                                            }
2308                                          else
2309                                            {
2310                                              /* 33222222222211111111110000000000
2311                                                 10987654321098765432109876543210
2312                                                 101110001x0xxxxxxxxxx1xxxxxxxxxx
2313                                                 ldrsw.  */
2314                                              return 879;
2315                                            }
2316                                        }
2317                                      else
2318                                        {
2319                                          /* 33222222222211111111110000000000
2320                                             10987654321098765432109876543210
2321                                             x11110001x0xxxxxxxxxx1xxxxxxxxxx
2322                                             ldrsh.  */
2323                                          return 876;
2324                                        }
2325                                    }
2326                                }
2327                              else
2328                                {
2329                                  if (((word >> 23) & 0x1) == 0)
2330                                    {
2331                                      /* 33222222222211111111110000000000
2332                                         10987654321098765432109876543210
2333                                         xx1110000x1xxxxxxxxxx1xxxxxxxxxx
2334                                         ldraa.  */
2335                                      return 934;
2336                                    }
2337                                  else
2338                                    {
2339                                      /* 33222222222211111111110000000000
2340                                         10987654321098765432109876543210
2341                                         xx1110001x1xxxxxxxxxx1xxxxxxxxxx
2342                                         ldrab.  */
2343                                      return 935;
2344                                    }
2345                                }
2346                            }
2347                        }
2348                    }
2349                  else
2350                    {
2351                      if (((word >> 23) & 0x1) == 0)
2352                        {
2353                          if (((word >> 22) & 0x1) == 0)
2354                            {
2355                              if (((word >> 29) & 0x1) == 0)
2356                                {
2357                                  if (((word >> 10) & 0x1) == 0)
2358                                    {
2359                                      if (((word >> 11) & 0x1) == 0)
2360                                        {
2361                                          if (((word >> 21) & 0x1) == 0)
2362                                            {
2363                                              if (((word >> 30) & 0x1) == 0)
2364                                                {
2365                                                  if (((word >> 31) & 0x1) == 0)
2366                                                    {
2367                                                      /* 33222222222211111111110000000000
2368                                                         10987654321098765432109876543210
2369                                                         00011001000xxxxxxxxx00xxxxxxxxxx
2370                                                         stlurb.  */
2371                                                      return 2377;
2372                                                    }
2373                                                  else
2374                                                    {
2375                                                      /* 33222222222211111111110000000000
2376                                                         10987654321098765432109876543210
2377                                                         10011001000xxxxxxxxx00xxxxxxxxxx
2378                                                         stlur.  */
2379                                                      return 2385;
2380                                                    }
2381                                                }
2382                                              else
2383                                                {
2384                                                  if (((word >> 31) & 0x1) == 0)
2385                                                    {
2386                                                      /* 33222222222211111111110000000000
2387                                                         10987654321098765432109876543210
2388                                                         01011001000xxxxxxxxx00xxxxxxxxxx
2389                                                         stlurh.  */
2390                                                      return 2381;
2391                                                    }
2392                                                  else
2393                                                    {
2394                                                      /* 33222222222211111111110000000000
2395                                                         10987654321098765432109876543210
2396                                                         11011001000xxxxxxxxx00xxxxxxxxxx
2397                                                         stlur.  */
2398                                                      return 2388;
2399                                                    }
2400                                                }
2401                                            }
2402                                          else
2403                                            {
2404                                              /* 33222222222211111111110000000000
2405                                                 10987654321098765432109876543210
2406                                                 xx011001001xxxxxxxxx00xxxxxxxxxx
2407                                                 stzgm.  */
2408                                              return 963;
2409                                            }
2410                                        }
2411                                      else
2412                                        {
2413                                          /* 33222222222211111111110000000000
2414                                             10987654321098765432109876543210
2415                                             xx01100100xxxxxxxxxx10xxxxxxxxxx
2416                                             stg.  */
2417                                          return 880;
2418                                        }
2419                                    }
2420                                  else
2421                                    {
2422                                      /* 33222222222211111111110000000000
2423                                         10987654321098765432109876543210
2424                                         xx01100100xxxxxxxxxxx1xxxxxxxxxx
2425                                         stg.  */
2426                                      return 884;
2427                                    }
2428                                }
2429                              else
2430                                {
2431                                  if (((word >> 31) & 0x1) == 0)
2432                                    {
2433                                      if (((word >> 30) & 0x1) == 0)
2434                                        {
2435                                          /* 33222222222211111111110000000000
2436                                             10987654321098765432109876543210
2437                                             0011100100xxxxxxxxxxxxxxxxxxxxxx
2438                                             strb.  */
2439                                          return 888;
2440                                        }
2441                                      else
2442                                        {
2443                                          /* 33222222222211111111110000000000
2444                                             10987654321098765432109876543210
2445                                             0111100100xxxxxxxxxxxxxxxxxxxxxx
2446                                             strh.  */
2447                                          return 893;
2448                                        }
2449                                    }
2450                                  else
2451                                    {
2452                                      /* 33222222222211111111110000000000
2453                                         10987654321098765432109876543210
2454                                         1x11100100xxxxxxxxxxxxxxxxxxxxxx
2455                                         str.  */
2456                                      return 896;
2457                                    }
2458                                }
2459                            }
2460                          else
2461                            {
2462                              if (((word >> 29) & 0x1) == 0)
2463                                {
2464                                  if (((word >> 10) & 0x1) == 0)
2465                                    {
2466                                      if (((word >> 11) & 0x1) == 0)
2467                                        {
2468                                          if (((word >> 21) & 0x1) == 0)
2469                                            {
2470                                              if (((word >> 30) & 0x1) == 0)
2471                                                {
2472                                                  if (((word >> 31) & 0x1) == 0)
2473                                                    {
2474                                                      /* 33222222222211111111110000000000
2475                                                         10987654321098765432109876543210
2476                                                         00011001010xxxxxxxxx00xxxxxxxxxx
2477                                                         ldapurb.  */
2478                                                      return 2378;
2479                                                    }
2480                                                  else
2481                                                    {
2482                                                      /* 33222222222211111111110000000000
2483                                                         10987654321098765432109876543210
2484                                                         10011001010xxxxxxxxx00xxxxxxxxxx
2485                                                         ldapur.  */
2486                                                      return 2386;
2487                                                    }
2488                                                }
2489                                              else
2490                                                {
2491                                                  if (((word >> 31) & 0x1) == 0)
2492                                                    {
2493                                                      /* 33222222222211111111110000000000
2494                                                         10987654321098765432109876543210
2495                                                         01011001010xxxxxxxxx00xxxxxxxxxx
2496                                                         ldapurh.  */
2497                                                      return 2382;
2498                                                    }
2499                                                  else
2500                                                    {
2501                                                      /* 33222222222211111111110000000000
2502                                                         10987654321098765432109876543210
2503                                                         11011001010xxxxxxxxx00xxxxxxxxxx
2504                                                         ldapur.  */
2505                                                      return 2389;
2506                                                    }
2507                                                }
2508                                            }
2509                                          else
2510                                            {
2511                                              /* 33222222222211111111110000000000
2512                                                 10987654321098765432109876543210
2513                                                 xx011001011xxxxxxxxx00xxxxxxxxxx
2514                                                 ldg.  */
2515                                              return 933;
2516                                            }
2517                                        }
2518                                      else
2519                                        {
2520                                          /* 33222222222211111111110000000000
2521                                             10987654321098765432109876543210
2522                                             xx01100101xxxxxxxxxx10xxxxxxxxxx
2523                                             stzg.  */
2524                                          return 881;
2525                                        }
2526                                    }
2527                                  else
2528                                    {
2529                                      /* 33222222222211111111110000000000
2530                                         10987654321098765432109876543210
2531                                         xx01100101xxxxxxxxxxx1xxxxxxxxxx
2532                                         stzg.  */
2533                                      return 885;
2534                                    }
2535                                }
2536                              else
2537                                {
2538                                  if (((word >> 31) & 0x1) == 0)
2539                                    {
2540                                      if (((word >> 30) & 0x1) == 0)
2541                                        {
2542                                          /* 33222222222211111111110000000000
2543                                             10987654321098765432109876543210
2544                                             0011100101xxxxxxxxxxxxxxxxxxxxxx
2545                                             ldrb.  */
2546                                          return 889;
2547                                        }
2548                                      else
2549                                        {
2550                                          /* 33222222222211111111110000000000
2551                                             10987654321098765432109876543210
2552                                             0111100101xxxxxxxxxxxxxxxxxxxxxx
2553                                             ldrh.  */
2554                                          return 894;
2555                                        }
2556                                    }
2557                                  else
2558                                    {
2559                                      /* 33222222222211111111110000000000
2560                                         10987654321098765432109876543210
2561                                         1x11100101xxxxxxxxxxxxxxxxxxxxxx
2562                                         ldr.  */
2563                                      return 897;
2564                                    }
2565                                }
2566                            }
2567                        }
2568                      else
2569                        {
2570                          if (((word >> 29) & 0x1) == 0)
2571                            {
2572                              if (((word >> 10) & 0x1) == 0)
2573                                {
2574                                  if (((word >> 11) & 0x1) == 0)
2575                                    {
2576                                      if (((word >> 21) & 0x1) == 0)
2577                                        {
2578                                          if (((word >> 22) & 0x1) == 0)
2579                                            {
2580                                              if (((word >> 30) & 0x1) == 0)
2581                                                {
2582                                                  if (((word >> 31) & 0x1) == 0)
2583                                                    {
2584                                                      /* 33222222222211111111110000000000
2585                                                         10987654321098765432109876543210
2586                                                         00011001100xxxxxxxxx00xxxxxxxxxx
2587                                                         ldapursb.  */
2588                                                      return 2380;
2589                                                    }
2590                                                  else
2591                                                    {
2592                                                      /* 33222222222211111111110000000000
2593                                                         10987654321098765432109876543210
2594                                                         10011001100xxxxxxxxx00xxxxxxxxxx
2595                                                         ldapursw.  */
2596                                                      return 2387;
2597                                                    }
2598                                                }
2599                                              else
2600                                                {
2601                                                  /* 33222222222211111111110000000000
2602                                                     10987654321098765432109876543210
2603                                                     x1011001100xxxxxxxxx00xxxxxxxxxx
2604                                                     ldapursh.  */
2605                                                  return 2384;
2606                                                }
2607                                            }
2608                                          else
2609                                            {
2610                                              if (((word >> 30) & 0x1) == 0)
2611                                                {
2612                                                  /* 33222222222211111111110000000000
2613                                                     10987654321098765432109876543210
2614                                                     x0011001110xxxxxxxxx00xxxxxxxxxx
2615                                                     ldapursb.  */
2616                                                  return 2379;
2617                                                }
2618                                              else
2619                                                {
2620                                                  /* 33222222222211111111110000000000
2621                                                     10987654321098765432109876543210
2622                                                     x1011001110xxxxxxxxx00xxxxxxxxxx
2623                                                     ldapursh.  */
2624                                                  return 2383;
2625                                                }
2626                                            }
2627                                        }
2628                                      else
2629                                        {
2630                                          if (((word >> 22) & 0x1) == 0)
2631                                            {
2632                                              /* 33222222222211111111110000000000
2633                                                 10987654321098765432109876543210
2634                                                 xx011001101xxxxxxxxx00xxxxxxxxxx
2635                                                 stgm.  */
2636                                              return 962;
2637                                            }
2638                                          else
2639                                            {
2640                                              /* 33222222222211111111110000000000
2641                                                 10987654321098765432109876543210
2642                                                 xx011001111xxxxxxxxx00xxxxxxxxxx
2643                                                 ldgm.  */
2644                                              return 961;
2645                                            }
2646                                        }
2647                                    }
2648                                  else
2649                                    {
2650                                      if (((word >> 22) & 0x1) == 0)
2651                                        {
2652                                          /* 33222222222211111111110000000000
2653                                             10987654321098765432109876543210
2654                                             xx01100110xxxxxxxxxx10xxxxxxxxxx
2655                                             st2g.  */
2656                                          return 882;
2657                                        }
2658                                      else
2659                                        {
2660                                          /* 33222222222211111111110000000000
2661                                             10987654321098765432109876543210
2662                                             xx01100111xxxxxxxxxx10xxxxxxxxxx
2663                                             stz2g.  */
2664                                          return 883;
2665                                        }
2666                                    }
2667                                }
2668                              else
2669                                {
2670                                  if (((word >> 22) & 0x1) == 0)
2671                                    {
2672                                      /* 33222222222211111111110000000000
2673                                         10987654321098765432109876543210
2674                                         xx01100110xxxxxxxxxxx1xxxxxxxxxx
2675                                         st2g.  */
2676                                      return 886;
2677                                    }
2678                                  else
2679                                    {
2680                                      /* 33222222222211111111110000000000
2681                                         10987654321098765432109876543210
2682                                         xx01100111xxxxxxxxxxx1xxxxxxxxxx
2683                                         stz2g.  */
2684                                      return 887;
2685                                    }
2686                                }
2687                            }
2688                          else
2689                            {
2690                              if (((word >> 30) & 0x1) == 0)
2691                                {
2692                                  if (((word >> 31) & 0x1) == 0)
2693                                    {
2694                                      /* 33222222222211111111110000000000
2695                                         10987654321098765432109876543210
2696                                         001110011xxxxxxxxxxxxxxxxxxxxxxx
2697                                         ldrsb.  */
2698                                      return 890;
2699                                    }
2700                                  else
2701                                    {
2702                                      /* 33222222222211111111110000000000
2703                                         10987654321098765432109876543210
2704                                         101110011xxxxxxxxxxxxxxxxxxxxxxx
2705                                         ldrsw.  */
2706                                      return 898;
2707                                    }
2708                                }
2709                              else
2710                                {
2711                                  if (((word >> 31) & 0x1) == 0)
2712                                    {
2713                                      /* 33222222222211111111110000000000
2714                                         10987654321098765432109876543210
2715                                         011110011xxxxxxxxxxxxxxxxxxxxxxx
2716                                         ldrsh.  */
2717                                      return 895;
2718                                    }
2719                                  else
2720                                    {
2721                                      /* 33222222222211111111110000000000
2722                                         10987654321098765432109876543210
2723                                         111110011xxxxxxxxxxxxxxxxxxxxxxx
2724                                         prfm.  */
2725                                      return 899;
2726                                    }
2727                                }
2728                            }
2729                        }
2730                    }
2731                }
2732            }
2733        }
2734      else
2735        {
2736          if (((word >> 24) & 0x1) == 0)
2737            {
2738              if (((word >> 27) & 0x1) == 0)
2739                {
2740                  if (((word >> 23) & 0x1) == 0)
2741                    {
2742                      if (((word >> 29) & 0x1) == 0)
2743                        {
2744                          if (((word >> 30) & 0x1) == 0)
2745                            {
2746                              /* 33222222222211111111110000000000
2747                                 10987654321098765432109876543210
2748                                 x00x00100xxxxxxxxxxxxxxxxxxxxxxx
2749                                 and.  */
2750                              return 990;
2751                            }
2752                          else
2753                            {
2754                              /* 33222222222211111111110000000000
2755                                 10987654321098765432109876543210
2756                                 x10x00100xxxxxxxxxxxxxxxxxxxxxxx
2757                                 eor.  */
2758                              return 994;
2759                            }
2760                        }
2761                      else
2762                        {
2763                          if (((word >> 30) & 0x1) == 0)
2764                            {
2765                              /* 33222222222211111111110000000000
2766                                 10987654321098765432109876543210
2767                                 x01x00100xxxxxxxxxxxxxxxxxxxxxxx
2768                                 orr.  */
2769                              return 992;
2770                            }
2771                          else
2772                            {
2773                              /* 33222222222211111111110000000000
2774                                 10987654321098765432109876543210
2775                                 x11x00100xxxxxxxxxxxxxxxxxxxxxxx
2776                                 ands.  */
2777                              return 995;
2778                            }
2779                        }
2780                    }
2781                  else
2782                    {
2783                      if (((word >> 29) & 0x1) == 0)
2784                        {
2785                          if (((word >> 30) & 0x1) == 0)
2786                            {
2787                              /* 33222222222211111111110000000000
2788                                 10987654321098765432109876543210
2789                                 x00x00101xxxxxxxxxxxxxxxxxxxxxxx
2790                                 movn.  */
2791                              return 1181;
2792                            }
2793                          else
2794                            {
2795                              /* 33222222222211111111110000000000
2796                                 10987654321098765432109876543210
2797                                 x10x00101xxxxxxxxxxxxxxxxxxxxxxx
2798                                 movz.  */
2799                              return 1183;
2800                            }
2801                        }
2802                      else
2803                        {
2804                          /* 33222222222211111111110000000000
2805                             10987654321098765432109876543210
2806                             xx1x00101xxxxxxxxxxxxxxxxxxxxxxx
2807                             movk.  */
2808                          return 1185;
2809                        }
2810                    }
2811                }
2812              else
2813                {
2814                  if (((word >> 21) & 0x1) == 0)
2815                    {
2816                      if (((word >> 28) & 0x1) == 0)
2817                        {
2818                          if (((word >> 29) & 0x1) == 0)
2819                            {
2820                              if (((word >> 30) & 0x1) == 0)
2821                                {
2822                                  /* 33222222222211111111110000000000
2823                                     10987654321098765432109876543210
2824                                     x0001010xx0xxxxxxxxxxxxxxxxxxxxx
2825                                     and.  */
2826                                  return 997;
2827                                }
2828                              else
2829                                {
2830                                  /* 33222222222211111111110000000000
2831                                     10987654321098765432109876543210
2832                                     x1001010xx0xxxxxxxxxxxxxxxxxxxxx
2833                                     eor.  */
2834                                  return 1004;
2835                                }
2836                            }
2837                          else
2838                            {
2839                              if (((word >> 30) & 0x1) == 0)
2840                                {
2841                                  /* 33222222222211111111110000000000
2842                                     10987654321098765432109876543210
2843                                     x0101010xx0xxxxxxxxxxxxxxxxxxxxx
2844                                     orr.  */
2845                                  return 999;
2846                                }
2847                              else
2848                                {
2849                                  /* 33222222222211111111110000000000
2850                                     10987654321098765432109876543210
2851                                     x1101010xx0xxxxxxxxxxxxxxxxxxxxx
2852                                     ands.  */
2853                                  return 1006;
2854                                }
2855                            }
2856                        }
2857                      else
2858                        {
2859                          if (((word >> 10) & 0x1) == 0)
2860                            {
2861                              if (((word >> 11) & 0x1) == 0)
2862                                {
2863                                  if (((word >> 22) & 0x1) == 0)
2864                                    {
2865                                      if (((word >> 23) & 0x1) == 0)
2866                                        {
2867                                          if (((word >> 29) & 0x1) == 0)
2868                                            {
2869                                              if (((word >> 30) & 0x1) == 0)
2870                                                {
2871                                                  /* 33222222222211111111110000000000
2872                                                     10987654321098765432109876543210
2873                                                     x0011010000xxxxxxxxx00xxxxxxxxxx
2874                                                     adc.  */
2875                                                  return 0;
2876                                                }
2877                                              else
2878                                                {
2879                                                  /* 33222222222211111111110000000000
2880                                                     10987654321098765432109876543210
2881                                                     x1011010000xxxxxxxxx00xxxxxxxxxx
2882                                                     sbc.  */
2883                                                  return 2;
2884                                                }
2885                                            }
2886                                          else
2887                                            {
2888                                              if (((word >> 30) & 0x1) == 0)
2889                                                {
2890                                                  /* 33222222222211111111110000000000
2891                                                     10987654321098765432109876543210
2892                                                     x0111010000xxxxxxxxx00xxxxxxxxxx
2893                                                     adcs.  */
2894                                                  return 1;
2895                                                }
2896                                              else
2897                                                {
2898                                                  /* 33222222222211111111110000000000
2899                                                     10987654321098765432109876543210
2900                                                     x1111010000xxxxxxxxx00xxxxxxxxxx
2901                                                     sbcs.  */
2902                                                  return 4;
2903                                                }
2904                                            }
2905                                        }
2906                                      else
2907                                        {
2908                                          if (((word >> 30) & 0x1) == 0)
2909                                            {
2910                                              /* 33222222222211111111110000000000
2911                                                 10987654321098765432109876543210
2912                                                 x0x11010100xxxxxxxxx00xxxxxxxxxx
2913                                                 csel.  */
2914                                              return 662;
2915                                            }
2916                                          else
2917                                            {
2918                                              /* 33222222222211111111110000000000
2919                                                 10987654321098765432109876543210
2920                                                 x1x11010100xxxxxxxxx00xxxxxxxxxx
2921                                                 csinv.  */
2922                                              return 666;
2923                                            }
2924                                        }
2925                                    }
2926                                  else
2927                                    {
2928                                      if (((word >> 23) & 0x1) == 0)
2929                                        {
2930                                          if (((word >> 30) & 0x1) == 0)
2931                                            {
2932                                              /* 33222222222211111111110000000000
2933                                                 10987654321098765432109876543210
2934                                                 x0x11010010xxxxxxxxx00xxxxxxxxxx
2935                                                 ccmn.  */
2936                                              return 660;
2937                                            }
2938                                          else
2939                                            {
2940                                              /* 33222222222211111111110000000000
2941                                                 10987654321098765432109876543210
2942                                                 x1x11010010xxxxxxxxx00xxxxxxxxxx
2943                                                 ccmp.  */
2944                                              return 661;
2945                                            }
2946                                        }
2947                                      else
2948                                        {
2949                                          if (((word >> 12) & 0x1) == 0)
2950                                            {
2951                                              if (((word >> 13) & 0x1) == 0)
2952                                                {
2953                                                  if (((word >> 14) & 0x1) == 0)
2954                                                    {
2955                                                      if (((word >> 29) & 0x1) == 0)
2956                                                        {
2957                                                          if (((word >> 30) & 0x1) == 0)
2958                                                            {
2959                                                              /* 33222222222211111111110000000000
2960                                                                 10987654321098765432109876543210
2961                                                                 x0011010110xxxxxx00000xxxxxxxxxx
2962                                                                 subp.  */
2963                                                              return 721;
2964                                                            }
2965                                                          else
2966                                                            {
2967                                                              if (((word >> 16) & 0x1) == 0)
2968                                                                {
2969                                                                  /* 33222222222211111111110000000000
2970                                                                     10987654321098765432109876543210
2971                                                                     x1011010110xxxx0x00000xxxxxxxxxx
2972                                                                     rbit.  */
2973                                                                  return 685;
2974                                                                }
2975                                                              else
2976                                                                {
2977                                                                  /* 33222222222211111111110000000000
2978                                                                     10987654321098765432109876543210
2979                                                                     x1011010110xxxx1x00000xxxxxxxxxx
2980                                                                     pacia.  */
2981                                                                  return 693;
2982                                                                }
2983                                                            }
2984                                                        }
2985                                                      else
2986                                                        {
2987                                                          /* 33222222222211111111110000000000
2988                                                             10987654321098765432109876543210
2989                                                             xx111010110xxxxxx00000xxxxxxxxxx
2990                                                             subps.  */
2991                                                          return 722;
2992                                                        }
2993                                                    }
2994                                                  else
2995                                                    {
2996                                                      if (((word >> 30) & 0x1) == 0)
2997                                                        {
2998                                                          /* 33222222222211111111110000000000
2999                                                             10987654321098765432109876543210
3000                                                             x0x11010110xxxxxx10000xxxxxxxxxx
3001                                                             crc32b.  */
3002                                                          return 727;
3003                                                        }
3004                                                      else
3005                                                        {
3006                                                          /* 33222222222211111111110000000000
3007                                                             10987654321098765432109876543210
3008                                                             x1x11010110xxxxxx10000xxxxxxxxxx
3009                                                             xpaci.  */
3010                                                          return 709;
3011                                                        }
3012                                                    }
3013                                                }
3014                                              else
3015                                                {
3016                                                  if (((word >> 30) & 0x1) == 0)
3017                                                    {
3018                                                      /* 33222222222211111111110000000000
3019                                                         10987654321098765432109876543210
3020                                                         x0x11010110xxxxxxx1000xxxxxxxxxx
3021                                                         lslv.  */
3022                                                      return 713;
3023                                                    }
3024                                                  else
3025                                                    {
3026                                                      /* 33222222222211111111110000000000
3027                                                         10987654321098765432109876543210
3028                                                         x1x11010110xxxxxxx1000xxxxxxxxxx
3029                                                         paciza.  */
3030                                                      return 701;
3031                                                    }
3032                                                }
3033                                            }
3034                                          else
3035                                            {
3036                                              if (((word >> 13) & 0x1) == 0)
3037                                                {
3038                                                  if (((word >> 14) & 0x1) == 0)
3039                                                    {
3040                                                      if (((word >> 30) & 0x1) == 0)
3041                                                        {
3042                                                          /* 33222222222211111111110000000000
3043                                                             10987654321098765432109876543210
3044                                                             x0x11010110xxxxxx00100xxxxxxxxxx
3045                                                             irg.  */
3046                                                          return 724;
3047                                                        }
3048                                                      else
3049                                                        {
3050                                                          if (((word >> 16) & 0x1) == 0)
3051                                                            {
3052                                                              /* 33222222222211111111110000000000
3053                                                                 10987654321098765432109876543210
3054                                                                 x1x11010110xxxx0x00100xxxxxxxxxx
3055                                                                 clz.  */
3056                                                              return 690;
3057                                                            }
3058                                                          else
3059                                                            {
3060                                                              /* 33222222222211111111110000000000
3061                                                                 10987654321098765432109876543210
3062                                                                 x1x11010110xxxx1x00100xxxxxxxxxx
3063                                                                 autia.  */
3064                                                              return 697;
3065                                                            }
3066                                                        }
3067                                                    }
3068                                                  else
3069                                                    {
3070                                                      /* 33222222222211111111110000000000
3071                                                         10987654321098765432109876543210
3072                                                         xxx11010110xxxxxx10100xxxxxxxxxx
3073                                                         crc32cb.  */
3074                                                      return 731;
3075                                                    }
3076                                                }
3077                                              else
3078                                                {
3079                                                  if (((word >> 30) & 0x1) == 0)
3080                                                    {
3081                                                      /* 33222222222211111111110000000000
3082                                                         10987654321098765432109876543210
3083                                                         x0x11010110xxxxxxx1100xxxxxxxxxx
3084                                                         pacga.  */
3085                                                      return 726;
3086                                                    }
3087                                                  else
3088                                                    {
3089                                                      /* 33222222222211111111110000000000
3090                                                         10987654321098765432109876543210
3091                                                         x1x11010110xxxxxxx1100xxxxxxxxxx
3092                                                         autiza.  */
3093                                                      return 705;
3094                                                    }
3095                                                }
3096                                            }
3097                                        }
3098                                    }
3099                                }
3100                              else
3101                                {
3102                                  if (((word >> 22) & 0x1) == 0)
3103                                    {
3104                                      if (((word >> 14) & 0x1) == 0)
3105                                        {
3106                                          /* 33222222222211111111110000000000
3107                                             10987654321098765432109876543210
3108                                             xxx11010x00xxxxxx0xx10xxxxxxxxxx
3109                                             setf8.  */
3110                                          return 2375;
3111                                        }
3112                                      else
3113                                        {
3114                                          /* 33222222222211111111110000000000
3115                                             10987654321098765432109876543210
3116                                             xxx11010x00xxxxxx1xx10xxxxxxxxxx
3117                                             setf16.  */
3118                                          return 2376;
3119                                        }
3120                                    }
3121                                  else
3122                                    {
3123                                      if (((word >> 23) & 0x1) == 0)
3124                                        {
3125                                          if (((word >> 30) & 0x1) == 0)
3126                                            {
3127                                              /* 33222222222211111111110000000000
3128                                                 10987654321098765432109876543210
3129                                                 x0x11010010xxxxxxxxx10xxxxxxxxxx
3130                                                 ccmn.  */
3131                                              return 658;
3132                                            }
3133                                          else
3134                                            {
3135                                              /* 33222222222211111111110000000000
3136                                                 10987654321098765432109876543210
3137                                                 x1x11010010xxxxxxxxx10xxxxxxxxxx
3138                                                 ccmp.  */
3139                                              return 659;
3140                                            }
3141                                        }
3142                                      else
3143                                        {
3144                                          if (((word >> 12) & 0x1) == 0)
3145                                            {
3146                                              if (((word >> 13) & 0x1) == 0)
3147                                                {
3148                                                  if (((word >> 14) & 0x1) == 0)
3149                                                    {
3150                                                      if (((word >> 30) & 0x1) == 0)
3151                                                        {
3152                                                          /* 33222222222211111111110000000000
3153                                                             10987654321098765432109876543210
3154                                                             x0x11010110xxxxxx00010xxxxxxxxxx
3155                                                             udiv.  */
3156                                                          return 711;
3157                                                        }
3158                                                      else
3159                                                        {
3160                                                          if (((word >> 16) & 0x1) == 0)
3161                                                            {
3162                                                              if (((word >> 31) & 0x1) == 0)
3163                                                                {
3164                                                                  /* 33222222222211111111110000000000
3165                                                                     10987654321098765432109876543210
3166                                                                     01x11010110xxxx0x00010xxxxxxxxxx
3167                                                                     rev.  */
3168                                                                  return 687;
3169                                                                }
3170                                                              else
3171                                                                {
3172                                                                  /* 33222222222211111111110000000000
3173                                                                     10987654321098765432109876543210
3174                                                                     11x11010110xxxx0x00010xxxxxxxxxx
3175                                                                     rev32.  */
3176                                                                  return 692;
3177                                                                }
3178                                                            }
3179                                                          else
3180                                                            {
3181                                                              /* 33222222222211111111110000000000
3182                                                                 10987654321098765432109876543210
3183                                                                 x1x11010110xxxx1x00010xxxxxxxxxx
3184                                                                 pacda.  */
3185                                                              return 695;
3186                                                            }
3187                                                        }
3188                                                    }
3189                                                  else
3190                                                    {
3191                                                      /* 33222222222211111111110000000000
3192                                                         10987654321098765432109876543210
3193                                                         xxx11010110xxxxxx10010xxxxxxxxxx
3194                                                         crc32w.  */
3195                                                      return 729;
3196                                                    }
3197                                                }
3198                                              else
3199                                                {
3200                                                  if (((word >> 30) & 0x1) == 0)
3201                                                    {
3202                                                      /* 33222222222211111111110000000000
3203                                                         10987654321098765432109876543210
3204                                                         x0x11010110xxxxxxx1010xxxxxxxxxx
3205                                                         asrv.  */
3206                                                      return 717;
3207                                                    }
3208                                                  else
3209                                                    {
3210                                                      /* 33222222222211111111110000000000
3211                                                         10987654321098765432109876543210
3212                                                         x1x11010110xxxxxxx1010xxxxxxxxxx
3213                                                         pacdza.  */
3214                                                      return 703;
3215                                                    }
3216                                                }
3217                                            }
3218                                          else
3219                                            {
3220                                              if (((word >> 13) & 0x1) == 0)
3221                                                {
3222                                                  if (((word >> 14) & 0x1) == 0)
3223                                                    {
3224                                                      /* 33222222222211111111110000000000
3225                                                         10987654321098765432109876543210
3226                                                         xxx11010110xxxxxx00110xxxxxxxxxx
3227                                                         autda.  */
3228                                                      return 699;
3229                                                    }
3230                                                  else
3231                                                    {
3232                                                      /* 33222222222211111111110000000000
3233                                                         10987654321098765432109876543210
3234                                                         xxx11010110xxxxxx10110xxxxxxxxxx
3235                                                         crc32cw.  */
3236                                                      return 733;
3237                                                    }
3238                                                }
3239                                              else
3240                                                {
3241                                                  /* 33222222222211111111110000000000
3242                                                     10987654321098765432109876543210
3243                                                     xxx11010110xxxxxxx1110xxxxxxxxxx
3244                                                     autdza.  */
3245                                                  return 707;
3246                                                }
3247                                            }
3248                                        }
3249                                    }
3250                                }
3251                            }
3252                          else
3253                            {
3254                              if (((word >> 11) & 0x1) == 0)
3255                                {
3256                                  if (((word >> 22) & 0x1) == 0)
3257                                    {
3258                                      if (((word >> 23) & 0x1) == 0)
3259                                        {
3260                                          /* 33222222222211111111110000000000
3261                                             10987654321098765432109876543210
3262                                             xxx11010000xxxxxxxxx01xxxxxxxxxx
3263                                             rmif.  */
3264                                          return 2374;
3265                                        }
3266                                      else
3267                                        {
3268                                          if (((word >> 30) & 0x1) == 0)
3269                                            {
3270                                              /* 33222222222211111111110000000000
3271                                                 10987654321098765432109876543210
3272                                                 x0x11010100xxxxxxxxx01xxxxxxxxxx
3273                                                 csinc.  */
3274                                              return 663;
3275                                            }
3276                                          else
3277                                            {
3278                                              /* 33222222222211111111110000000000
3279                                                 10987654321098765432109876543210
3280                                                 x1x11010100xxxxxxxxx01xxxxxxxxxx
3281                                                 csneg.  */
3282                                              return 669;
3283                                            }
3284                                        }
3285                                    }
3286                                  else
3287                                    {
3288                                      if (((word >> 12) & 0x1) == 0)
3289                                        {
3290                                          if (((word >> 13) & 0x1) == 0)
3291                                            {
3292                                              if (((word >> 14) & 0x1) == 0)
3293                                                {
3294                                                  if (((word >> 16) & 0x1) == 0)
3295                                                    {
3296                                                      /* 33222222222211111111110000000000
3297                                                         10987654321098765432109876543210
3298                                                         xxx11010x10xxxx0x00001xxxxxxxxxx
3299                                                         rev16.  */
3300                                                      return 686;
3301                                                    }
3302                                                  else
3303                                                    {
3304                                                      /* 33222222222211111111110000000000
3305                                                         10987654321098765432109876543210
3306                                                         xxx11010x10xxxx1x00001xxxxxxxxxx
3307                                                         pacib.  */
3308                                                      return 694;
3309                                                    }
3310                                                }
3311                                              else
3312                                                {
3313                                                  if (((word >> 30) & 0x1) == 0)
3314                                                    {
3315                                                      /* 33222222222211111111110000000000
3316                                                         10987654321098765432109876543210
3317                                                         x0x11010x10xxxxxx10001xxxxxxxxxx
3318                                                         crc32h.  */
3319                                                      return 728;
3320                                                    }
3321                                                  else
3322                                                    {
3323                                                      /* 33222222222211111111110000000000
3324                                                         10987654321098765432109876543210
3325                                                         x1x11010x10xxxxxx10001xxxxxxxxxx
3326                                                         xpacd.  */
3327                                                      return 710;
3328                                                    }
3329                                                }
3330                                            }
3331                                          else
3332                                            {
3333                                              if (((word >> 30) & 0x1) == 0)
3334                                                {
3335                                                  /* 33222222222211111111110000000000
3336                                                     10987654321098765432109876543210
3337                                                     x0x11010x10xxxxxxx1001xxxxxxxxxx
3338                                                     lsrv.  */
3339                                                  return 715;
3340                                                }
3341                                              else
3342                                                {
3343                                                  /* 33222222222211111111110000000000
3344                                                     10987654321098765432109876543210
3345                                                     x1x11010x10xxxxxxx1001xxxxxxxxxx
3346                                                     pacizb.  */
3347                                                  return 702;
3348                                                }
3349                                            }
3350                                        }
3351                                      else
3352                                        {
3353                                          if (((word >> 13) & 0x1) == 0)
3354                                            {
3355                                              if (((word >> 14) & 0x1) == 0)
3356                                                {
3357                                                  if (((word >> 30) & 0x1) == 0)
3358                                                    {
3359                                                      /* 33222222222211111111110000000000
3360                                                         10987654321098765432109876543210
3361                                                         x0x11010x10xxxxxx00101xxxxxxxxxx
3362                                                         gmi.  */
3363                                                      return 725;
3364                                                    }
3365                                                  else
3366                                                    {
3367                                                      if (((word >> 16) & 0x1) == 0)
3368                                                        {
3369                                                          /* 33222222222211111111110000000000
3370                                                             10987654321098765432109876543210
3371                                                             x1x11010x10xxxx0x00101xxxxxxxxxx
3372                                                             cls.  */
3373                                                          return 691;
3374                                                        }
3375                                                      else
3376                                                        {
3377                                                          /* 33222222222211111111110000000000
3378                                                             10987654321098765432109876543210
3379                                                             x1x11010x10xxxx1x00101xxxxxxxxxx
3380                                                             autib.  */
3381                                                          return 698;
3382                                                        }
3383                                                    }
3384                                                }
3385                                              else
3386                                                {
3387                                                  /* 33222222222211111111110000000000
3388                                                     10987654321098765432109876543210
3389                                                     xxx11010x10xxxxxx10101xxxxxxxxxx
3390                                                     crc32ch.  */
3391                                                  return 732;
3392                                                }
3393                                            }
3394                                          else
3395                                            {
3396                                              /* 33222222222211111111110000000000
3397                                                 10987654321098765432109876543210
3398                                                 xxx11010x10xxxxxxx1101xxxxxxxxxx
3399                                                 autizb.  */
3400                                              return 706;
3401                                            }
3402                                        }
3403                                    }
3404                                }
3405                              else
3406                                {
3407                                  if (((word >> 12) & 0x1) == 0)
3408                                    {
3409                                      if (((word >> 13) & 0x1) == 0)
3410                                        {
3411                                          if (((word >> 14) & 0x1) == 0)
3412                                            {
3413                                              if (((word >> 30) & 0x1) == 0)
3414                                                {
3415                                                  /* 33222222222211111111110000000000
3416                                                     10987654321098765432109876543210
3417                                                     x0x11010xx0xxxxxx00011xxxxxxxxxx
3418                                                     sdiv.  */
3419                                                  return 712;
3420                                                }
3421                                              else
3422                                                {
3423                                                  if (((word >> 16) & 0x1) == 0)
3424                                                    {
3425                                                      /* 33222222222211111111110000000000
3426                                                         10987654321098765432109876543210
3427                                                         x1x11010xx0xxxx0x00011xxxxxxxxxx
3428                                                         rev.  */
3429                                                      return 688;
3430                                                    }
3431                                                  else
3432                                                    {
3433                                                      /* 33222222222211111111110000000000
3434                                                         10987654321098765432109876543210
3435                                                         x1x11010xx0xxxx1x00011xxxxxxxxxx
3436                                                         pacdb.  */
3437                                                      return 696;
3438                                                    }
3439                                                }
3440                                            }
3441                                          else
3442                                            {
3443                                              /* 33222222222211111111110000000000
3444                                                 10987654321098765432109876543210
3445                                                 xxx11010xx0xxxxxx10011xxxxxxxxxx
3446                                                 crc32x.  */
3447                                              return 730;
3448                                            }
3449                                        }
3450                                      else
3451                                        {
3452                                          if (((word >> 30) & 0x1) == 0)
3453                                            {
3454                                              /* 33222222222211111111110000000000
3455                                                 10987654321098765432109876543210
3456                                                 x0x11010xx0xxxxxxx1011xxxxxxxxxx
3457                                                 rorv.  */
3458                                              return 719;
3459                                            }
3460                                          else
3461                                            {
3462                                              /* 33222222222211111111110000000000
3463                                                 10987654321098765432109876543210
3464                                                 x1x11010xx0xxxxxxx1011xxxxxxxxxx
3465                                                 pacdzb.  */
3466                                              return 704;
3467                                            }
3468                                        }
3469                                    }
3470                                  else
3471                                    {
3472                                      if (((word >> 13) & 0x1) == 0)
3473                                        {
3474                                          if (((word >> 14) & 0x1) == 0)
3475                                            {
3476                                              /* 33222222222211111111110000000000
3477                                                 10987654321098765432109876543210
3478                                                 xxx11010xx0xxxxxx00111xxxxxxxxxx
3479                                                 autdb.  */
3480                                              return 700;
3481                                            }
3482                                          else
3483                                            {
3484                                              /* 33222222222211111111110000000000
3485                                                 10987654321098765432109876543210
3486                                                 xxx11010xx0xxxxxx10111xxxxxxxxxx
3487                                                 crc32cx.  */
3488                                              return 734;
3489                                            }
3490                                        }
3491                                      else
3492                                        {
3493                                          /* 33222222222211111111110000000000
3494                                             10987654321098765432109876543210
3495                                             xxx11010xx0xxxxxxx1111xxxxxxxxxx
3496                                             autdzb.  */
3497                                          return 708;
3498                                        }
3499                                    }
3500                                }
3501                            }
3502                        }
3503                    }
3504                  else
3505                    {
3506                      if (((word >> 29) & 0x1) == 0)
3507                        {
3508                          if (((word >> 30) & 0x1) == 0)
3509                            {
3510                              /* 33222222222211111111110000000000
3511                                 10987654321098765432109876543210
3512                                 x00x1010xx1xxxxxxxxxxxxxxxxxxxxx
3513                                 bic.  */
3514                              return 998;
3515                            }
3516                          else
3517                            {
3518                              /* 33222222222211111111110000000000
3519                                 10987654321098765432109876543210
3520                                 x10x1010xx1xxxxxxxxxxxxxxxxxxxxx
3521                                 eon.  */
3522                              return 1005;
3523                            }
3524                        }
3525                      else
3526                        {
3527                          if (((word >> 30) & 0x1) == 0)
3528                            {
3529                              /* 33222222222211111111110000000000
3530                                 10987654321098765432109876543210
3531                                 x01x1010xx1xxxxxxxxxxxxxxxxxxxxx
3532                                 orn.  */
3533                              return 1002;
3534                            }
3535                          else
3536                            {
3537                              /* 33222222222211111111110000000000
3538                                 10987654321098765432109876543210
3539                                 x11x1010xx1xxxxxxxxxxxxxxxxxxxxx
3540                                 bics.  */
3541                              return 1008;
3542                            }
3543                        }
3544                    }
3545                }
3546            }
3547          else
3548            {
3549              if (((word >> 27) & 0x1) == 0)
3550                {
3551                  if (((word >> 23) & 0x1) == 0)
3552                    {
3553                      if (((word >> 29) & 0x1) == 0)
3554                        {
3555                          if (((word >> 30) & 0x1) == 0)
3556                            {
3557                              /* 33222222222211111111110000000000
3558                                 10987654321098765432109876543210
3559                                 x00x00110xxxxxxxxxxxxxxxxxxxxxxx
3560                                 sbfm.  */
3561                              return 618;
3562                            }
3563                          else
3564                            {
3565                              /* 33222222222211111111110000000000
3566                                 10987654321098765432109876543210
3567                                 x10x00110xxxxxxxxxxxxxxxxxxxxxxx
3568                                 ubfm.  */
3569                              return 629;
3570                            }
3571                        }
3572                      else
3573                        {
3574                          /* 33222222222211111111110000000000
3575                             10987654321098765432109876543210
3576                             xx1x00110xxxxxxxxxxxxxxxxxxxxxxx
3577                             bfm.  */
3578                          return 625;
3579                        }
3580                    }
3581                  else
3582                    {
3583                      /* 33222222222211111111110000000000
3584                         10987654321098765432109876543210
3585                         xxxx00111xxxxxxxxxxxxxxxxxxxxxxx
3586                         extr.  */
3587                      return 757;
3588                    }
3589                }
3590              else
3591                {
3592                  if (((word >> 21) & 0x1) == 0)
3593                    {
3594                      if (((word >> 28) & 0x1) == 0)
3595                        {
3596                          if (((word >> 29) & 0x1) == 0)
3597                            {
3598                              if (((word >> 30) & 0x1) == 0)
3599                                {
3600                                  /* 33222222222211111111110000000000
3601                                     10987654321098765432109876543210
3602                                     x0001011xx0xxxxxxxxxxxxxxxxxxxxx
3603                                     add.  */
3604                                  return 21;
3605                                }
3606                              else
3607                                {
3608                                  /* 33222222222211111111110000000000
3609                                     10987654321098765432109876543210
3610                                     x1001011xx0xxxxxxxxxxxxxxxxxxxxx
3611                                     sub.  */
3612                                  return 24;
3613                                }
3614                            }
3615                          else
3616                            {
3617                              if (((word >> 30) & 0x1) == 0)
3618                                {
3619                                  /* 33222222222211111111110000000000
3620                                     10987654321098765432109876543210
3621                                     x0101011xx0xxxxxxxxxxxxxxxxxxxxx
3622                                     adds.  */
3623                                  return 22;
3624                                }
3625                              else
3626                                {
3627                                  /* 33222222222211111111110000000000
3628                                     10987654321098765432109876543210
3629                                     x1101011xx0xxxxxxxxxxxxxxxxxxxxx
3630                                     subs.  */
3631                                  return 26;
3632                                }
3633                            }
3634                        }
3635                      else
3636                        {
3637                          if (((word >> 15) & 0x1) == 0)
3638                            {
3639                              if (((word >> 22) & 0x1) == 0)
3640                                {
3641                                  /* 33222222222211111111110000000000
3642                                     10987654321098765432109876543210
3643                                     xxx11011x00xxxxx0xxxxxxxxxxxxxxx
3644                                     madd.  */
3645                                  return 735;
3646                                }
3647                              else
3648                                {
3649                                  if (((word >> 23) & 0x1) == 0)
3650                                    {
3651                                      /* 33222222222211111111110000000000
3652                                         10987654321098765432109876543210
3653                                         xxx11011010xxxxx0xxxxxxxxxxxxxxx
3654                                         smulh.  */
3655                                      return 743;
3656                                    }
3657                                  else
3658                                    {
3659                                      /* 33222222222211111111110000000000
3660                                         10987654321098765432109876543210
3661                                         xxx11011110xxxxx0xxxxxxxxxxxxxxx
3662                                         umulh.  */
3663                                      return 748;
3664                                    }
3665                                }
3666                            }
3667                          else
3668                            {
3669                              /* 33222222222211111111110000000000
3670                                 10987654321098765432109876543210
3671                                 xxx11011xx0xxxxx1xxxxxxxxxxxxxxx
3672                                 msub.  */
3673                              return 737;
3674                            }
3675                        }
3676                    }
3677                  else
3678                    {
3679                      if (((word >> 23) & 0x1) == 0)
3680                        {
3681                          if (((word >> 28) & 0x1) == 0)
3682                            {
3683                              if (((word >> 29) & 0x1) == 0)
3684                                {
3685                                  if (((word >> 30) & 0x1) == 0)
3686                                    {
3687                                      /* 33222222222211111111110000000000
3688                                         10987654321098765432109876543210
3689                                         x00010110x1xxxxxxxxxxxxxxxxxxxxx
3690                                         add.  */
3691                                      return 6;
3692                                    }
3693                                  else
3694                                    {
3695                                      /* 33222222222211111111110000000000
3696                                         10987654321098765432109876543210
3697                                         x10010110x1xxxxxxxxxxxxxxxxxxxxx
3698                                         sub.  */
3699                                      return 9;
3700                                    }
3701                                }
3702                              else
3703                                {
3704                                  if (((word >> 30) & 0x1) == 0)
3705                                    {
3706                                      /* 33222222222211111111110000000000
3707                                         10987654321098765432109876543210
3708                                         x01010110x1xxxxxxxxxxxxxxxxxxxxx
3709                                         adds.  */
3710                                      return 7;
3711                                    }
3712                                  else
3713                                    {
3714                                      /* 33222222222211111111110000000000
3715                                         10987654321098765432109876543210
3716                                         x11010110x1xxxxxxxxxxxxxxxxxxxxx
3717                                         subs.  */
3718                                      return 10;
3719                                    }
3720                                }
3721                            }
3722                          else
3723                            {
3724                              if (((word >> 15) & 0x1) == 0)
3725                                {
3726                                  /* 33222222222211111111110000000000
3727                                     10987654321098765432109876543210
3728                                     xxx110110x1xxxxx0xxxxxxxxxxxxxxx
3729                                     smaddl.  */
3730                                  return 739;
3731                                }
3732                              else
3733                                {
3734                                  /* 33222222222211111111110000000000
3735                                     10987654321098765432109876543210
3736                                     xxx110110x1xxxxx1xxxxxxxxxxxxxxx
3737                                     smsubl.  */
3738                                  return 741;
3739                                }
3740                            }
3741                        }
3742                      else
3743                        {
3744                          if (((word >> 15) & 0x1) == 0)
3745                            {
3746                              /* 33222222222211111111110000000000
3747                                 10987654321098765432109876543210
3748                                 xxxx10111x1xxxxx0xxxxxxxxxxxxxxx
3749                                 umaddl.  */
3750                              return 744;
3751                            }
3752                          else
3753                            {
3754                              /* 33222222222211111111110000000000
3755                                 10987654321098765432109876543210
3756                                 xxxx10111x1xxxxx1xxxxxxxxxxxxxxx
3757                                 umsubl.  */
3758                              return 746;
3759                            }
3760                        }
3761                    }
3762                }
3763            }
3764        }
3765    }
3766  else
3767    {
3768      if (((word >> 27) & 0x1) == 0)
3769        {
3770          if (((word >> 28) & 0x1) == 0)
3771            {
3772              if (((word >> 24) & 0x1) == 0)
3773                {
3774                  if (((word >> 29) & 0x1) == 0)
3775                    {
3776                      if (((word >> 13) & 0x1) == 0)
3777                        {
3778                          if (((word >> 14) & 0x1) == 0)
3779                            {
3780                              if (((word >> 15) & 0x1) == 0)
3781                                {
3782                                  if (((word >> 21) & 0x1) == 0)
3783                                    {
3784                                      if (((word >> 30) & 0x1) == 0)
3785                                        {
3786                                          if (((word >> 31) & 0x1) == 0)
3787                                            {
3788                                              if (((word >> 16) & 0x1) == 0)
3789                                                {
3790                                                  if (((word >> 17) & 0x1) == 0)
3791                                                    {
3792                                                      if (((word >> 18) & 0x1) == 0)
3793                                                        {
3794                                                          if (((word >> 19) & 0x1) == 0)
3795                                                            {
3796                                                              if (((word >> 20) & 0x1) == 0)
3797                                                                {
3798                                                                  /* 33222222222211111111110000000000
3799                                                                     10987654321098765432109876543210
3800                                                                     000001x0xx000000000xxxxxxxxxxxxx
3801                                                                     add.  */
3802                                                                  return 1276;
3803                                                                }
3804                                                              else
3805                                                                {
3806                                                                  /* 33222222222211111111110000000000
3807                                                                     10987654321098765432109876543210
3808                                                                     000001x0xx010000000xxxxxxxxxxxxx
3809                                                                     mul.  */
3810                                                                  return 1745;
3811                                                                }
3812                                                            }
3813                                                          else
3814                                                            {
3815                                                              if (((word >> 20) & 0x1) == 0)
3816                                                                {
3817                                                                  /* 33222222222211111111110000000000
3818                                                                     10987654321098765432109876543210
3819                                                                     000001x0xx001000000xxxxxxxxxxxxx
3820                                                                     smax.  */
3821                                                                  return 1824;
3822                                                                }
3823                                                              else
3824                                                                {
3825                                                                  /* 33222222222211111111110000000000
3826                                                                     10987654321098765432109876543210
3827                                                                     000001x0xx011000000xxxxxxxxxxxxx
3828                                                                     orr.  */
3829                                                                  return 1756;
3830                                                                }
3831                                                            }
3832                                                        }
3833                                                      else
3834                                                        {
3835                                                          if (((word >> 19) & 0x1) == 0)
3836                                                            {
3837                                                              /* 33222222222211111111110000000000
3838                                                                 10987654321098765432109876543210
3839                                                                 000001x0xx0x0100000xxxxxxxxxxxxx
3840                                                                 sdiv.  */
3841                                                              return 1815;
3842                                                            }
3843                                                          else
3844                                                            {
3845                                                              /* 33222222222211111111110000000000
3846                                                                 10987654321098765432109876543210
3847                                                                 000001x0xx0x1100000xxxxxxxxxxxxx
3848                                                                 sabd.  */
3849                                                              return 1806;
3850                                                            }
3851                                                        }
3852                                                    }
3853                                                  else
3854                                                    {
3855                                                      if (((word >> 18) & 0x1) == 0)
3856                                                        {
3857                                                          if (((word >> 19) & 0x1) == 0)
3858                                                            {
3859                                                              /* 33222222222211111111110000000000
3860                                                                 10987654321098765432109876543210
3861                                                                 000001x0xx0x0010000xxxxxxxxxxxxx
3862                                                                 smulh.  */
3863                                                              return 1829;
3864                                                            }
3865                                                          else
3866                                                            {
3867                                                              if (((word >> 20) & 0x1) == 0)
3868                                                                {
3869                                                                  /* 33222222222211111111110000000000
3870                                                                     10987654321098765432109876543210
3871                                                                     000001x0xx001010000xxxxxxxxxxxxx
3872                                                                     smin.  */
3873                                                                  return 1827;
3874                                                                }
3875                                                              else
3876                                                                {
3877                                                                  /* 33222222222211111111110000000000
3878                                                                     10987654321098765432109876543210
3879                                                                     000001x0xx011010000xxxxxxxxxxxxx
3880                                                                     and.  */
3881                                                                  return 1284;
3882                                                                }
3883                                                            }
3884                                                        }
3885                                                      else
3886                                                        {
3887                                                          /* 33222222222211111111110000000000
3888                                                             10987654321098765432109876543210
3889                                                             000001x0xx0xx110000xxxxxxxxxxxxx
3890                                                             sdivr.  */
3891                                                          return 1816;
3892                                                        }
3893                                                    }
3894                                                }
3895                                              else
3896                                                {
3897                                                  if (((word >> 17) & 0x1) == 0)
3898                                                    {
3899                                                      if (((word >> 18) & 0x1) == 0)
3900                                                        {
3901                                                          if (((word >> 19) & 0x1) == 0)
3902                                                            {
3903                                                              /* 33222222222211111111110000000000
3904                                                                 10987654321098765432109876543210
3905                                                                 000001x0xx0x0001000xxxxxxxxxxxxx
3906                                                                 sub.  */
3907                                                              return 1945;
3908                                                            }
3909                                                          else
3910                                                            {
3911                                                              if (((word >> 20) & 0x1) == 0)
3912                                                                {
3913                                                                  /* 33222222222211111111110000000000
3914                                                                     10987654321098765432109876543210
3915                                                                     000001x0xx001001000xxxxxxxxxxxxx
3916                                                                     umax.  */
3917                                                                  return 1973;
3918                                                                }
3919                                                              else
3920                                                                {
3921                                                                  /* 33222222222211111111110000000000
3922                                                                     10987654321098765432109876543210
3923                                                                     000001x0xx011001000xxxxxxxxxxxxx
3924                                                                     eor.  */
3925                                                                  return 1371;
3926                                                                }
3927                                                            }
3928                                                        }
3929                                                      else
3930                                                        {
3931                                                          if (((word >> 19) & 0x1) == 0)
3932                                                            {
3933                                                              /* 33222222222211111111110000000000
3934                                                                 10987654321098765432109876543210
3935                                                                 000001x0xx0x0101000xxxxxxxxxxxxx
3936                                                                 udiv.  */
3937                                                              return 1967;
3938                                                            }
3939                                                          else
3940                                                            {
3941                                                              /* 33222222222211111111110000000000
3942                                                                 10987654321098765432109876543210
3943                                                                 000001x0xx0x1101000xxxxxxxxxxxxx
3944                                                                 uabd.  */
3945                                                              return 1958;
3946                                                            }
3947                                                        }
3948                                                    }
3949                                                  else
3950                                                    {
3951                                                      if (((word >> 18) & 0x1) == 0)
3952                                                        {
3953                                                          if (((word >> 19) & 0x1) == 0)
3954                                                            {
3955                                                              if (((word >> 20) & 0x1) == 0)
3956                                                                {
3957                                                                  /* 33222222222211111111110000000000
3958                                                                     10987654321098765432109876543210
3959                                                                     000001x0xx000011000xxxxxxxxxxxxx
3960                                                                     subr.  */
3961                                                                  return 1947;
3962                                                                }
3963                                                              else
3964                                                                {
3965                                                                  /* 33222222222211111111110000000000
3966                                                                     10987654321098765432109876543210
3967                                                                     000001x0xx010011000xxxxxxxxxxxxx
3968                                                                     umulh.  */
3969                                                                  return 1978;
3970                                                                }
3971                                                            }
3972                                                          else
3973                                                            {
3974                                                              if (((word >> 20) & 0x1) == 0)
3975                                                                {
3976                                                                  /* 33222222222211111111110000000000
3977                                                                     10987654321098765432109876543210
3978                                                                     000001x0xx001011000xxxxxxxxxxxxx
3979                                                                     umin.  */
3980                                                                  return 1976;
3981                                                                }
3982                                                              else
3983                                                                {
3984                                                                  /* 33222222222211111111110000000000
3985                                                                     10987654321098765432109876543210
3986                                                                     000001x0xx011011000xxxxxxxxxxxxx
3987                                                                     bic.  */
3988                                                                  return 1296;
3989                                                                }
3990                                                            }
3991                                                        }
3992                                                      else
3993                                                        {
3994                                                          /* 33222222222211111111110000000000
3995                                                             10987654321098765432109876543210
3996                                                             000001x0xx0xx111000xxxxxxxxxxxxx
3997                                                             udivr.  */
3998                                                          return 1968;
3999                                                        }
4000                                                    }
4001                                                }
4002                                            }
4003                                          else
4004                                            {
4005                                              if (((word >> 23) & 0x1) == 0)
4006                                                {
4007                                                  /* 33222222222211111111110000000000
4008                                                     10987654321098765432109876543210
4009                                                     100001x00x0xxxxx000xxxxxxxxxxxxx
4010                                                     ld1sb.  */
4011                                                  return 1558;
4012                                                }
4013                                              else
4014                                                {
4015                                                  /* 33222222222211111111110000000000
4016                                                     10987654321098765432109876543210
4017                                                     100001x01x0xxxxx000xxxxxxxxxxxxx
4018                                                     ld1sh.  */
4019                                                  return 1569;
4020                                                }
4021                                            }
4022                                        }
4023                                      else
4024                                        {
4025                                          if (((word >> 31) & 0x1) == 0)
4026                                            {
4027                                              if (((word >> 12) & 0x1) == 0)
4028                                                {
4029                                                  if (((word >> 10) & 0x1) == 0)
4030                                                    {
4031                                                      if (((word >> 11) & 0x1) == 0)
4032                                                        {
4033                                                          /* 33222222222211111111110000000000
4034                                                             10987654321098765432109876543210
4035                                                             010001x0xx0xxxxx000000xxxxxxxxxx
4036                                                             sdot.  */
4037                                                          return 1817;
4038                                                        }
4039                                                      else
4040                                                        {
4041                                                          /* 33222222222211111111110000000000
4042                                                             10987654321098765432109876543210
4043                                                             010001x0xx0xxxxx000010xxxxxxxxxx
4044                                                             sqdmlalbt.  */
4045                                                          return 2167;
4046                                                        }
4047                                                    }
4048                                                  else
4049                                                    {
4050                                                      if (((word >> 11) & 0x1) == 0)
4051                                                        {
4052                                                          /* 33222222222211111111110000000000
4053                                                             10987654321098765432109876543210
4054                                                             010001x0xx0xxxxx000001xxxxxxxxxx
4055                                                             udot.  */
4056                                                          return 1969;
4057                                                        }
4058                                                      else
4059                                                        {
4060                                                          /* 33222222222211111111110000000000
4061                                                             10987654321098765432109876543210
4062                                                             010001x0xx0xxxxx000011xxxxxxxxxx
4063                                                             sqdmlslbt.  */
4064                                                          return 2174;
4065                                                        }
4066                                                    }
4067                                                }
4068                                              else
4069                                                {
4070                                                  /* 33222222222211111111110000000000
4071                                                     10987654321098765432109876543210
4072                                                     010001x0xx0xxxxx0001xxxxxxxxxxxx
4073                                                     cdot.  */
4074                                                  return 2056;
4075                                                }
4076                                            }
4077                                          else
4078                                            {
4079                                              if (((word >> 23) & 0x1) == 0)
4080                                                {
4081                                                  /* 33222222222211111111110000000000
4082                                                     10987654321098765432109876543210
4083                                                     110001x00x0xxxxx000xxxxxxxxxxxxx
4084                                                     ld1sb.  */
4085                                                  return 1562;
4086                                                }
4087                                              else
4088                                                {
4089                                                  /* 33222222222211111111110000000000
4090                                                     10987654321098765432109876543210
4091                                                     110001x01x0xxxxx000xxxxxxxxxxxxx
4092                                                     ld1sh.  */
4093                                                  return 1573;
4094                                                }
4095                                            }
4096                                        }
4097                                    }
4098                                  else
4099                                    {
4100                                      if (((word >> 30) & 0x1) == 0)
4101                                        {
4102                                          if (((word >> 31) & 0x1) == 0)
4103                                            {
4104                                              if (((word >> 10) & 0x1) == 0)
4105                                                {
4106                                                  if (((word >> 11) & 0x1) == 0)
4107                                                    {
4108                                                      if (((word >> 12) & 0x1) == 0)
4109                                                        {
4110                                                          /* 33222222222211111111110000000000
4111                                                             10987654321098765432109876543210
4112                                                             000001x0xx1xxxxx000000xxxxxxxxxx
4113                                                             add.  */
4114                                                          return 1274;
4115                                                        }
4116                                                      else
4117                                                        {
4118                                                          /* 33222222222211111111110000000000
4119                                                             10987654321098765432109876543210
4120                                                             000001x0xx1xxxxx000100xxxxxxxxxx
4121                                                             sqadd.  */
4122                                                          return 1831;
4123                                                        }
4124                                                    }
4125                                                  else
4126                                                    {
4127                                                      /* 33222222222211111111110000000000
4128                                                         10987654321098765432109876543210
4129                                                         000001x0xx1xxxxx000x10xxxxxxxxxx
4130                                                         sqsub.  */
4131                                                      return 1861;
4132                                                    }
4133                                                }
4134                                              else
4135                                                {
4136                                                  if (((word >> 11) & 0x1) == 0)
4137                                                    {
4138                                                      if (((word >> 12) & 0x1) == 0)
4139                                                        {
4140                                                          /* 33222222222211111111110000000000
4141                                                             10987654321098765432109876543210
4142                                                             000001x0xx1xxxxx000001xxxxxxxxxx
4143                                                             sub.  */
4144                                                          return 1943;
4145                                                        }
4146                                                      else
4147                                                        {
4148                                                          /* 33222222222211111111110000000000
4149                                                             10987654321098765432109876543210
4150                                                             000001x0xx1xxxxx000101xxxxxxxxxx
4151                                                             uqadd.  */
4152                                                          return 1979;
4153                                                        }
4154                                                    }
4155                                                  else
4156                                                    {
4157                                                      /* 33222222222211111111110000000000
4158                                                         10987654321098765432109876543210
4159                                                         000001x0xx1xxxxx000x11xxxxxxxxxx
4160                                                         uqsub.  */
4161                                                      return 2009;
4162                                                    }
4163                                                }
4164                                            }
4165                                          else
4166                                            {
4167                                              if (((word >> 23) & 0x1) == 0)
4168                                                {
4169                                                  /* 33222222222211111111110000000000
4170                                                     10987654321098765432109876543210
4171                                                     100001x00x1xxxxx000xxxxxxxxxxxxx
4172                                                     prfb.  */
4173                                                  return 1764;
4174                                                }
4175                                              else
4176                                                {
4177                                                  /* 33222222222211111111110000000000
4178                                                     10987654321098765432109876543210
4179                                                     100001x01x1xxxxx000xxxxxxxxxxxxx
4180                                                     ld1sh.  */
4181                                                  return 1570;
4182                                                }
4183                                            }
4184                                        }
4185                                      else
4186                                        {
4187                                          if (((word >> 23) & 0x1) == 0)
4188                                            {
4189                                              if (((word >> 31) & 0x1) == 0)
4190                                                {
4191                                                  if (((word >> 10) & 0x1) == 0)
4192                                                    {
4193                                                      if (((word >> 11) & 0x1) == 0)
4194                                                        {
4195                                                          /* 33222222222211111111110000000000
4196                                                             10987654321098765432109876543210
4197                                                             010001x00x1xxxxx000x00xxxxxxxxxx
4198                                                             sqrdmlah.  */
4199                                                          return 2192;
4200                                                        }
4201                                                      else
4202                                                        {
4203                                                          /* 33222222222211111111110000000000
4204                                                             10987654321098765432109876543210
4205                                                             010001x00x1xxxxx000x10xxxxxxxxxx
4206                                                             mla.  */
4207                                                          return 2099;
4208                                                        }
4209                                                    }
4210                                                  else
4211                                                    {
4212                                                      if (((word >> 11) & 0x1) == 0)
4213                                                        {
4214                                                          /* 33222222222211111111110000000000
4215                                                             10987654321098765432109876543210
4216                                                             010001x00x1xxxxx000x01xxxxxxxxxx
4217                                                             sqrdmlsh.  */
4218                                                          return 2196;
4219                                                        }
4220                                                      else
4221                                                        {
4222                                                          /* 33222222222211111111110000000000
4223                                                             10987654321098765432109876543210
4224                                                             010001x00x1xxxxx000x11xxxxxxxxxx
4225                                                             mls.  */
4226                                                          return 2102;
4227                                                        }
4228                                                    }
4229                                                }
4230                                              else
4231                                                {
4232                                                  /* 33222222222211111111110000000000
4233                                                     10987654321098765432109876543210
4234                                                     110001x00x1xxxxx000xxxxxxxxxxxxx
4235                                                     prfb.  */
4236                                                  return 1765;
4237                                                }
4238                                            }
4239                                          else
4240                                            {
4241                                              if (((word >> 31) & 0x1) == 0)
4242                                                {
4243                                                  if (((word >> 10) & 0x1) == 0)
4244                                                    {
4245                                                      if (((word >> 11) & 0x1) == 0)
4246                                                        {
4247                                                          if (((word >> 12) & 0x1) == 0)
4248                                                            {
4249                                                              if (((word >> 22) & 0x1) == 0)
4250                                                                {
4251                                                                  /* 33222222222211111111110000000000
4252                                                                     10987654321098765432109876543210
4253                                                                     010001x0101xxxxx000000xxxxxxxxxx
4254                                                                     sdot.  */
4255                                                                  return 1818;
4256                                                                }
4257                                                              else
4258                                                                {
4259                                                                  /* 33222222222211111111110000000000
4260                                                                     10987654321098765432109876543210
4261                                                                     010001x0111xxxxx000000xxxxxxxxxx
4262                                                                     sdot.  */
4263                                                                  return 1819;
4264                                                                }
4265                                                            }
4266                                                          else
4267                                                            {
4268                                                              if (((word >> 22) & 0x1) == 0)
4269                                                                {
4270                                                                  /* 33222222222211111111110000000000
4271                                                                     10987654321098765432109876543210
4272                                                                     010001x0101xxxxx000100xxxxxxxxxx
4273                                                                     sqrdmlah.  */
4274                                                                  return 2193;
4275                                                                }
4276                                                              else
4277                                                                {
4278                                                                  /* 33222222222211111111110000000000
4279                                                                     10987654321098765432109876543210
4280                                                                     010001x0111xxxxx000100xxxxxxxxxx
4281                                                                     sqrdmlah.  */
4282                                                                  return 2194;
4283                                                                }
4284                                                            }
4285                                                        }
4286                                                      else
4287                                                        {
4288                                                          if (((word >> 12) & 0x1) == 0)
4289                                                            {
4290                                                              if (((word >> 22) & 0x1) == 0)
4291                                                                {
4292                                                                  /* 33222222222211111111110000000000
4293                                                                     10987654321098765432109876543210
4294                                                                     010001x0101xxxxx000010xxxxxxxxxx
4295                                                                     mla.  */
4296                                                                  return 2100;
4297                                                                }
4298                                                              else
4299                                                                {
4300                                                                  /* 33222222222211111111110000000000
4301                                                                     10987654321098765432109876543210
4302                                                                     010001x0111xxxxx000010xxxxxxxxxx
4303                                                                     mla.  */
4304                                                                  return 2101;
4305                                                                }
4306                                                            }
4307                                                          else
4308                                                            {
4309                                                              /* 33222222222211111111110000000000
4310                                                                 10987654321098765432109876543210
4311                                                                 010001x01x1xxxxx000110xxxxxxxxxx
4312                                                                 usdot.  */
4313                                                              return 2395;
4314                                                            }
4315                                                        }
4316                                                    }
4317                                                  else
4318                                                    {
4319                                                      if (((word >> 11) & 0x1) == 0)
4320                                                        {
4321                                                          if (((word >> 12) & 0x1) == 0)
4322                                                            {
4323                                                              if (((word >> 22) & 0x1) == 0)
4324                                                                {
4325                                                                  /* 33222222222211111111110000000000
4326                                                                     10987654321098765432109876543210
4327                                                                     010001x0101xxxxx000001xxxxxxxxxx
4328                                                                     udot.  */
4329                                                                  return 1970;
4330                                                                }
4331                                                              else
4332                                                                {
4333                                                                  /* 33222222222211111111110000000000
4334                                                                     10987654321098765432109876543210
4335                                                                     010001x0111xxxxx000001xxxxxxxxxx
4336                                                                     udot.  */
4337                                                                  return 1971;
4338                                                                }
4339                                                            }
4340                                                          else
4341                                                            {
4342                                                              if (((word >> 22) & 0x1) == 0)
4343                                                                {
4344                                                                  /* 33222222222211111111110000000000
4345                                                                     10987654321098765432109876543210
4346                                                                     010001x0101xxxxx000101xxxxxxxxxx
4347                                                                     sqrdmlsh.  */
4348                                                                  return 2197;
4349                                                                }
4350                                                              else
4351                                                                {
4352                                                                  /* 33222222222211111111110000000000
4353                                                                     10987654321098765432109876543210
4354                                                                     010001x0111xxxxx000101xxxxxxxxxx
4355                                                                     sqrdmlsh.  */
4356                                                                  return 2198;
4357                                                                }
4358                                                            }
4359                                                        }
4360                                                      else
4361                                                        {
4362                                                          if (((word >> 12) & 0x1) == 0)
4363                                                            {
4364                                                              if (((word >> 22) & 0x1) == 0)
4365                                                                {
4366                                                                  /* 33222222222211111111110000000000
4367                                                                     10987654321098765432109876543210
4368                                                                     010001x0101xxxxx000011xxxxxxxxxx
4369                                                                     mls.  */
4370                                                                  return 2103;
4371                                                                }
4372                                                              else
4373                                                                {
4374                                                                  /* 33222222222211111111110000000000
4375                                                                     10987654321098765432109876543210
4376                                                                     010001x0111xxxxx000011xxxxxxxxxx
4377                                                                     mls.  */
4378                                                                  return 2104;
4379                                                                }
4380                                                            }
4381                                                          else
4382                                                            {
4383                                                              /* 33222222222211111111110000000000
4384                                                                 10987654321098765432109876543210
4385                                                                 010001x01x1xxxxx000111xxxxxxxxxx
4386                                                                 sudot.  */
4387                                                              return 2396;
4388                                                            }
4389                                                        }
4390                                                    }
4391                                                }
4392                                              else
4393                                                {
4394                                                  /* 33222222222211111111110000000000
4395                                                     10987654321098765432109876543210
4396                                                     110001x01x1xxxxx000xxxxxxxxxxxxx
4397                                                     ld1sh.  */
4398                                                  return 1574;
4399                                                }
4400                                            }
4401                                        }
4402                                    }
4403                                }
4404                              else
4405                                {
4406                                  if (((word >> 31) & 0x1) == 0)
4407                                    {
4408                                      if (((word >> 21) & 0x1) == 0)
4409                                        {
4410                                          if (((word >> 16) & 0x1) == 0)
4411                                            {
4412                                              if (((word >> 17) & 0x1) == 0)
4413                                                {
4414                                                  if (((word >> 18) & 0x1) == 0)
4415                                                    {
4416                                                      if (((word >> 19) & 0x1) == 0)
4417                                                        {
4418                                                          if (((word >> 20) & 0x1) == 0)
4419                                                            {
4420                                                              /* 33222222222211111111110000000000
4421                                                                 10987654321098765432109876543210
4422                                                                 0x0001x0xx000000100xxxxxxxxxxxxx
4423                                                                 asr.  */
4424                                                              return 1292;
4425                                                            }
4426                                                          else
4427                                                            {
4428                                                              if (((word >> 30) & 0x1) == 0)
4429                                                                {
4430                                                                  /* 33222222222211111111110000000000
4431                                                                     10987654321098765432109876543210
4432                                                                     000001x0xx010000100xxxxxxxxxxxxx
4433                                                                     asr.  */
4434                                                                  return 1290;
4435                                                                }
4436                                                              else
4437                                                                {
4438                                                                  /* 33222222222211111111110000000000
4439                                                                     10987654321098765432109876543210
4440                                                                     010001x0xx010000100xxxxxxxxxxxxx
4441                                                                     shadd.  */
4442                                                                  return 2133;
4443                                                                }
4444                                                            }
4445                                                        }
4446                                                      else
4447                                                        {
4448                                                          if (((word >> 20) & 0x1) == 0)
4449                                                            {
4450                                                              /* 33222222222211111111110000000000
4451                                                                 10987654321098765432109876543210
4452                                                                 0x0001x0xx001000100xxxxxxxxxxxxx
4453                                                                 sqshl.  */
4454                                                              return 2211;
4455                                                            }
4456                                                          else
4457                                                            {
4458                                                              if (((word >> 30) & 0x1) == 0)
4459                                                                {
4460                                                                  /* 33222222222211111111110000000000
4461                                                                     10987654321098765432109876543210
4462                                                                     000001x0xx011000100xxxxxxxxxxxxx
4463                                                                     asr.  */
4464                                                                  return 1291;
4465                                                                }
4466                                                              else
4467                                                                {
4468                                                                  /* 33222222222211111111110000000000
4469                                                                     10987654321098765432109876543210
4470                                                                     010001x0xx011000100xxxxxxxxxxxxx
4471                                                                     sqadd.  */
4472                                                                  return 2162;
4473                                                                }
4474                                                            }
4475                                                        }
4476                                                    }
4477                                                  else
4478                                                    {
4479                                                      if (((word >> 19) & 0x1) == 0)
4480                                                        {
4481                                                          if (((word >> 20) & 0x1) == 0)
4482                                                            {
4483                                                              /* 33222222222211111111110000000000
4484                                                                 10987654321098765432109876543210
4485                                                                 0x0001x0xx000100100xxxxxxxxxxxxx
4486                                                                 asrd.  */
4487                                                              return 1293;
4488                                                            }
4489                                                          else
4490                                                            {
4491                                                              if (((word >> 30) & 0x1) == 0)
4492                                                                {
4493                                                                  /* 33222222222211111111110000000000
4494                                                                     10987654321098765432109876543210
4495                                                                     000001x0xx010100100xxxxxxxxxxxxx
4496                                                                     asrr.  */
4497                                                                  return 1294;
4498                                                                }
4499                                                              else
4500                                                                {
4501                                                                  /* 33222222222211111111110000000000
4502                                                                     10987654321098765432109876543210
4503                                                                     010001x0xx010100100xxxxxxxxxxxxx
4504                                                                     srhadd.  */
4505                                                                  return 2224;
4506                                                                }
4507                                                            }
4508                                                        }
4509                                                      else
4510                                                        {
4511                                                          if (((word >> 20) & 0x1) == 0)
4512                                                            {
4513                                                              if (((word >> 30) & 0x1) == 0)
4514                                                                {
4515                                                                  /* 33222222222211111111110000000000
4516                                                                     10987654321098765432109876543210
4517                                                                     000001x0xx001100100xxxxxxxxxxxxx
4518                                                                     srshr.  */
4519                                                                  return 2228;
4520                                                                }
4521                                                              else
4522                                                                {
4523                                                                  /* 33222222222211111111110000000000
4524                                                                     10987654321098765432109876543210
4525                                                                     010001x0xx001100100xxxxxxxxxxxxx
4526                                                                     sqshlr.  */
4527                                                                  return 2212;
4528                                                                }
4529                                                            }
4530                                                          else
4531                                                            {
4532                                                              /* 33222222222211111111110000000000
4533                                                                 10987654321098765432109876543210
4534                                                                 0x0001x0xx011100100xxxxxxxxxxxxx
4535                                                                 suqadd.  */
4536                                                              return 2248;
4537                                                            }
4538                                                        }
4539                                                    }
4540                                                }
4541                                              else
4542                                                {
4543                                                  if (((word >> 18) & 0x1) == 0)
4544                                                    {
4545                                                      if (((word >> 19) & 0x1) == 0)
4546                                                        {
4547                                                          if (((word >> 20) & 0x1) == 0)
4548                                                            {
4549                                                              /* 33222222222211111111110000000000
4550                                                                 10987654321098765432109876543210
4551                                                                 0x0001x0xx000010100xxxxxxxxxxxxx
4552                                                                 srshl.  */
4553                                                              return 2226;
4554                                                            }
4555                                                          else
4556                                                            {
4557                                                              /* 33222222222211111111110000000000
4558                                                                 10987654321098765432109876543210
4559                                                                 0x0001x0xx010010100xxxxxxxxxxxxx
4560                                                                 shsub.  */
4561                                                              return 2136;
4562                                                            }
4563                                                        }
4564                                                      else
4565                                                        {
4566                                                          if (((word >> 20) & 0x1) == 0)
4567                                                            {
4568                                                              /* 33222222222211111111110000000000
4569                                                                 10987654321098765432109876543210
4570                                                                 0x0001x0xx001010100xxxxxxxxxxxxx
4571                                                                 sqrshl.  */
4572                                                              return 2204;
4573                                                            }
4574                                                          else
4575                                                            {
4576                                                              /* 33222222222211111111110000000000
4577                                                                 10987654321098765432109876543210
4578                                                                 0x0001x0xx011010100xxxxxxxxxxxxx
4579                                                                 sqsub.  */
4580                                                              return 2218;
4581                                                            }
4582                                                        }
4583                                                    }
4584                                                  else
4585                                                    {
4586                                                      if (((word >> 19) & 0x1) == 0)
4587                                                        {
4588                                                          if (((word >> 20) & 0x1) == 0)
4589                                                            {
4590                                                              if (((word >> 30) & 0x1) == 0)
4591                                                                {
4592                                                                  /* 33222222222211111111110000000000
4593                                                                     10987654321098765432109876543210
4594                                                                     000001x0xx000110100xxxxxxxxxxxxx
4595                                                                     sqshl.  */
4596                                                                  return 2210;
4597                                                                }
4598                                                              else
4599                                                                {
4600                                                                  /* 33222222222211111111110000000000
4601                                                                     10987654321098765432109876543210
4602                                                                     010001x0xx000110100xxxxxxxxxxxxx
4603                                                                     srshlr.  */
4604                                                                  return 2227;
4605                                                                }
4606                                                            }
4607                                                          else
4608                                                            {
4609                                                              /* 33222222222211111111110000000000
4610                                                                 10987654321098765432109876543210
4611                                                                 0x0001x0xx010110100xxxxxxxxxxxxx
4612                                                                 shsubr.  */
4613                                                              return 2137;
4614                                                            }
4615                                                        }
4616                                                      else
4617                                                        {
4618                                                          if (((word >> 20) & 0x1) == 0)
4619                                                            {
4620                                                              /* 33222222222211111111110000000000
4621                                                                 10987654321098765432109876543210
4622                                                                 0x0001x0xx001110100xxxxxxxxxxxxx
4623                                                                 sqrshlr.  */
4624                                                              return 2205;
4625                                                            }
4626                                                          else
4627                                                            {
4628                                                              /* 33222222222211111111110000000000
4629                                                                 10987654321098765432109876543210
4630                                                                 0x0001x0xx011110100xxxxxxxxxxxxx
4631                                                                 sqsubr.  */
4632                                                              return 2219;
4633                                                            }
4634                                                        }
4635                                                    }
4636                                                }
4637                                            }
4638                                          else
4639                                            {
4640                                              if (((word >> 17) & 0x1) == 0)
4641                                                {
4642                                                  if (((word >> 18) & 0x1) == 0)
4643                                                    {
4644                                                      if (((word >> 19) & 0x1) == 0)
4645                                                        {
4646                                                          if (((word >> 20) & 0x1) == 0)
4647                                                            {
4648                                                              /* 33222222222211111111110000000000
4649                                                                 10987654321098765432109876543210
4650                                                                 0x0001x0xx000001100xxxxxxxxxxxxx
4651                                                                 lsr.  */
4652                                                              return 1736;
4653                                                            }
4654                                                          else
4655                                                            {
4656                                                              if (((word >> 30) & 0x1) == 0)
4657                                                                {
4658                                                                  /* 33222222222211111111110000000000
4659                                                                     10987654321098765432109876543210
4660                                                                     000001x0xx010001100xxxxxxxxxxxxx
4661                                                                     lsr.  */
4662                                                                  return 1734;
4663                                                                }
4664                                                              else
4665                                                                {
4666                                                                  /* 33222222222211111111110000000000
4667                                                                     10987654321098765432109876543210
4668                                                                     010001x0xx010001100xxxxxxxxxxxxx
4669                                                                     uhadd.  */
4670                                                                  return 2261;
4671                                                                }
4672                                                            }
4673                                                        }
4674                                                      else
4675                                                        {
4676                                                          if (((word >> 20) & 0x1) == 0)
4677                                                            {
4678                                                              /* 33222222222211111111110000000000
4679                                                                 10987654321098765432109876543210
4680                                                                 0x0001x0xx001001100xxxxxxxxxxxxx
4681                                                                 uqshl.  */
4682                                                              return 2291;
4683                                                            }
4684                                                          else
4685                                                            {
4686                                                              if (((word >> 30) & 0x1) == 0)
4687                                                                {
4688                                                                  /* 33222222222211111111110000000000
4689                                                                     10987654321098765432109876543210
4690                                                                     000001x0xx011001100xxxxxxxxxxxxx
4691                                                                     lsr.  */
4692                                                                  return 1735;
4693                                                                }
4694                                                              else
4695                                                                {
4696                                                                  /* 33222222222211111111110000000000
4697                                                                     10987654321098765432109876543210
4698                                                                     010001x0xx011001100xxxxxxxxxxxxx
4699                                                                     uqadd.  */
4700                                                                  return 2285;
4701                                                                }
4702                                                            }
4703                                                        }
4704                                                    }
4705                                                  else
4706                                                    {
4707                                                      if (((word >> 19) & 0x1) == 0)
4708                                                        {
4709                                                          if (((word >> 30) & 0x1) == 0)
4710                                                            {
4711                                                              /* 33222222222211111111110000000000
4712                                                                 10987654321098765432109876543210
4713                                                                 000001x0xx0x0101100xxxxxxxxxxxxx
4714                                                                 lsrr.  */
4715                                                              return 1737;
4716                                                            }
4717                                                          else
4718                                                            {
4719                                                              /* 33222222222211111111110000000000
4720                                                                 10987654321098765432109876543210
4721                                                                 010001x0xx0x0101100xxxxxxxxxxxxx
4722                                                                 urhadd.  */
4723                                                              return 2300;
4724                                                            }
4725                                                        }
4726                                                      else
4727                                                        {
4728                                                          if (((word >> 20) & 0x1) == 0)
4729                                                            {
4730                                                              if (((word >> 30) & 0x1) == 0)
4731                                                                {
4732                                                                  /* 33222222222211111111110000000000
4733                                                                     10987654321098765432109876543210
4734                                                                     000001x0xx001101100xxxxxxxxxxxxx
4735                                                                     urshr.  */
4736                                                                  return 2303;
4737                                                                }
4738                                                              else
4739                                                                {
4740                                                                  /* 33222222222211111111110000000000
4741                                                                     10987654321098765432109876543210
4742                                                                     010001x0xx001101100xxxxxxxxxxxxx
4743                                                                     uqshlr.  */
4744                                                                  return 2292;
4745                                                                }
4746                                                            }
4747                                                          else
4748                                                            {
4749                                                              /* 33222222222211111111110000000000
4750                                                                 10987654321098765432109876543210
4751                                                                 0x0001x0xx011101100xxxxxxxxxxxxx
4752                                                                 usqadd.  */
4753                                                              return 2308;
4754                                                            }
4755                                                        }
4756                                                    }
4757                                                }
4758                                              else
4759                                                {
4760                                                  if (((word >> 18) & 0x1) == 0)
4761                                                    {
4762                                                      if (((word >> 19) & 0x1) == 0)
4763                                                        {
4764                                                          if (((word >> 20) & 0x1) == 0)
4765                                                            {
4766                                                              if (((word >> 30) & 0x1) == 0)
4767                                                                {
4768                                                                  /* 33222222222211111111110000000000
4769                                                                     10987654321098765432109876543210
4770                                                                     000001x0xx000011100xxxxxxxxxxxxx
4771                                                                     lsl.  */
4772                                                                  return 1730;
4773                                                                }
4774                                                              else
4775                                                                {
4776                                                                  /* 33222222222211111111110000000000
4777                                                                     10987654321098765432109876543210
4778                                                                     010001x0xx000011100xxxxxxxxxxxxx
4779                                                                     urshl.  */
4780                                                                  return 2301;
4781                                                                }
4782                                                            }
4783                                                          else
4784                                                            {
4785                                                              if (((word >> 30) & 0x1) == 0)
4786                                                                {
4787                                                                  /* 33222222222211111111110000000000
4788                                                                     10987654321098765432109876543210
4789                                                                     000001x0xx010011100xxxxxxxxxxxxx
4790                                                                     lsl.  */
4791                                                                  return 1728;
4792                                                                }
4793                                                              else
4794                                                                {
4795                                                                  /* 33222222222211111111110000000000
4796                                                                     10987654321098765432109876543210
4797                                                                     010001x0xx010011100xxxxxxxxxxxxx
4798                                                                     uhsub.  */
4799                                                                  return 2262;
4800                                                                }
4801                                                            }
4802                                                        }
4803                                                      else
4804                                                        {
4805                                                          if (((word >> 20) & 0x1) == 0)
4806                                                            {
4807                                                              /* 33222222222211111111110000000000
4808                                                                 10987654321098765432109876543210
4809                                                                 0x0001x0xx001011100xxxxxxxxxxxxx
4810                                                                 uqrshl.  */
4811                                                              return 2286;
4812                                                            }
4813                                                          else
4814                                                            {
4815                                                              if (((word >> 30) & 0x1) == 0)
4816                                                                {
4817                                                                  /* 33222222222211111111110000000000
4818                                                                     10987654321098765432109876543210
4819                                                                     000001x0xx011011100xxxxxxxxxxxxx
4820                                                                     lsl.  */
4821                                                                  return 1729;
4822                                                                }
4823                                                              else
4824                                                                {
4825                                                                  /* 33222222222211111111110000000000
4826                                                                     10987654321098765432109876543210
4827                                                                     010001x0xx011011100xxxxxxxxxxxxx
4828                                                                     uqsub.  */
4829                                                                  return 2295;
4830                                                                }
4831                                                            }
4832                                                        }
4833                                                    }
4834                                                  else
4835                                                    {
4836                                                      if (((word >> 19) & 0x1) == 0)
4837                                                        {
4838                                                          if (((word >> 20) & 0x1) == 0)
4839                                                            {
4840                                                              if (((word >> 30) & 0x1) == 0)
4841                                                                {
4842                                                                  /* 33222222222211111111110000000000
4843                                                                     10987654321098765432109876543210
4844                                                                     000001x0xx000111100xxxxxxxxxxxxx
4845                                                                     uqshl.  */
4846                                                                  return 2290;
4847                                                                }
4848                                                              else
4849                                                                {
4850                                                                  /* 33222222222211111111110000000000
4851                                                                     10987654321098765432109876543210
4852                                                                     010001x0xx000111100xxxxxxxxxxxxx
4853                                                                     urshlr.  */
4854                                                                  return 2302;
4855                                                                }
4856                                                            }
4857                                                          else
4858                                                            {
4859                                                              if (((word >> 30) & 0x1) == 0)
4860                                                                {
4861                                                                  /* 33222222222211111111110000000000
4862                                                                     10987654321098765432109876543210
4863                                                                     000001x0xx010111100xxxxxxxxxxxxx
4864                                                                     lslr.  */
4865                                                                  return 1731;
4866                                                                }
4867                                                              else
4868                                                                {
4869                                                                  /* 33222222222211111111110000000000
4870                                                                     10987654321098765432109876543210
4871                                                                     010001x0xx010111100xxxxxxxxxxxxx
4872                                                                     uhsubr.  */
4873                                                                  return 2263;
4874                                                                }
4875                                                            }
4876                                                        }
4877                                                      else
4878                                                        {
4879                                                          if (((word >> 20) & 0x1) == 0)
4880                                                            {
4881                                                              if (((word >> 30) & 0x1) == 0)
4882                                                                {
4883                                                                  /* 33222222222211111111110000000000
4884                                                                     10987654321098765432109876543210
4885                                                                     000001x0xx001111100xxxxxxxxxxxxx
4886                                                                     sqshlu.  */
4887                                                                  return 2213;
4888                                                                }
4889                                                              else
4890                                                                {
4891                                                                  /* 33222222222211111111110000000000
4892                                                                     10987654321098765432109876543210
4893                                                                     010001x0xx001111100xxxxxxxxxxxxx
4894                                                                     uqrshlr.  */
4895                                                                  return 2287;
4896                                                                }
4897                                                            }
4898                                                          else
4899                                                            {
4900                                                              /* 33222222222211111111110000000000
4901                                                                 10987654321098765432109876543210
4902                                                                 0x0001x0xx011111100xxxxxxxxxxxxx
4903                                                                 uqsubr.  */
4904                                                              return 2296;
4905                                                            }
4906                                                        }
4907                                                    }
4908                                                }
4909                                            }
4910                                        }
4911                                      else
4912                                        {
4913                                          if (((word >> 10) & 0x1) == 0)
4914                                            {
4915                                              if (((word >> 12) & 0x1) == 0)
4916                                                {
4917                                                  if (((word >> 30) & 0x1) == 0)
4918                                                    {
4919                                                      /* 33222222222211111111110000000000
4920                                                         10987654321098765432109876543210
4921                                                         000001x0xx1xxxxx1000x0xxxxxxxxxx
4922                                                         asr.  */
4923                                                      return 1288;
4924                                                    }
4925                                                  else
4926                                                    {
4927                                                      if (((word >> 22) & 0x1) == 0)
4928                                                        {
4929                                                          /* 33222222222211111111110000000000
4930                                                             10987654321098765432109876543210
4931                                                             010001x0x01xxxxx1000x0xxxxxxxxxx
4932                                                             smlalb.  */
4933                                                          return 2141;
4934                                                        }
4935                                                      else
4936                                                        {
4937                                                          /* 33222222222211111111110000000000
4938                                                             10987654321098765432109876543210
4939                                                             010001x0x11xxxxx1000x0xxxxxxxxxx
4940                                                             smlalb.  */
4941                                                          return 2142;
4942                                                        }
4943                                                    }
4944                                                }
4945                                              else
4946                                                {
4947                                                  if (((word >> 30) & 0x1) == 0)
4948                                                    {
4949                                                      /* 33222222222211111111110000000000
4950                                                         10987654321098765432109876543210
4951                                                         000001x0xx1xxxxx1001x0xxxxxxxxxx
4952                                                         asr.  */
4953                                                      return 1289;
4954                                                    }
4955                                                  else
4956                                                    {
4957                                                      if (((word >> 22) & 0x1) == 0)
4958                                                        {
4959                                                          /* 33222222222211111111110000000000
4960                                                             10987654321098765432109876543210
4961                                                             010001x0x01xxxxx1001x0xxxxxxxxxx
4962                                                             umlalb.  */
4963                                                          return 2266;
4964                                                        }
4965                                                      else
4966                                                        {
4967                                                          /* 33222222222211111111110000000000
4968                                                             10987654321098765432109876543210
4969                                                             010001x0x11xxxxx1001x0xxxxxxxxxx
4970                                                             umlalb.  */
4971                                                          return 2267;
4972                                                        }
4973                                                    }
4974                                                }
4975                                            }
4976                                          else
4977                                            {
4978                                              if (((word >> 12) & 0x1) == 0)
4979                                                {
4980                                                  if (((word >> 30) & 0x1) == 0)
4981                                                    {
4982                                                      if (((word >> 11) & 0x1) == 0)
4983                                                        {
4984                                                          /* 33222222222211111111110000000000
4985                                                             10987654321098765432109876543210
4986                                                             000001x0xx1xxxxx100001xxxxxxxxxx
4987                                                             lsr.  */
4988                                                          return 1732;
4989                                                        }
4990                                                      else
4991                                                        {
4992                                                          /* 33222222222211111111110000000000
4993                                                             10987654321098765432109876543210
4994                                                             000001x0xx1xxxxx100011xxxxxxxxxx
4995                                                             lsl.  */
4996                                                          return 1726;
4997                                                        }
4998                                                    }
4999                                                  else
5000                                                    {
5001                                                      if (((word >> 22) & 0x1) == 0)
5002                                                        {
5003                                                          /* 33222222222211111111110000000000
5004                                                             10987654321098765432109876543210
5005                                                             010001x0x01xxxxx1000x1xxxxxxxxxx
5006                                                             smlalt.  */
5007                                                          return 2144;
5008                                                        }
5009                                                      else
5010                                                        {
5011                                                          /* 33222222222211111111110000000000
5012                                                             10987654321098765432109876543210
5013                                                             010001x0x11xxxxx1000x1xxxxxxxxxx
5014                                                             smlalt.  */
5015                                                          return 2145;
5016                                                        }
5017                                                    }
5018                                                }
5019                                              else
5020                                                {
5021                                                  if (((word >> 30) & 0x1) == 0)
5022                                                    {
5023                                                      if (((word >> 11) & 0x1) == 0)
5024                                                        {
5025                                                          /* 33222222222211111111110000000000
5026                                                             10987654321098765432109876543210
5027                                                             000001x0xx1xxxxx100101xxxxxxxxxx
5028                                                             lsr.  */
5029                                                          return 1733;
5030                                                        }
5031                                                      else
5032                                                        {
5033                                                          /* 33222222222211111111110000000000
5034                                                             10987654321098765432109876543210
5035                                                             000001x0xx1xxxxx100111xxxxxxxxxx
5036                                                             lsl.  */
5037                                                          return 1727;
5038                                                        }
5039                                                    }
5040                                                  else
5041                                                    {
5042                                                      if (((word >> 22) & 0x1) == 0)
5043                                                        {
5044                                                          /* 33222222222211111111110000000000
5045                                                             10987654321098765432109876543210
5046                                                             010001x0x01xxxxx1001x1xxxxxxxxxx
5047                                                             umlalt.  */
5048                                                          return 2269;
5049                                                        }
5050                                                      else
5051                                                        {
5052                                                          /* 33222222222211111111110000000000
5053                                                             10987654321098765432109876543210
5054                                                             010001x0x11xxxxx1001x1xxxxxxxxxx
5055                                                             umlalt.  */
5056                                                          return 2270;
5057                                                        }
5058                                                    }
5059                                                }
5060                                            }
5061                                        }
5062                                    }
5063                                  else
5064                                    {
5065                                      if (((word >> 22) & 0x1) == 0)
5066                                        {
5067                                          if (((word >> 21) & 0x1) == 0)
5068                                            {
5069                                              if (((word >> 23) & 0x1) == 0)
5070                                                {
5071                                                  /* 33222222222211111111110000000000
5072                                                     10987654321098765432109876543210
5073                                                     1x0001x0000xxxxx100xxxxxxxxxxxxx
5074                                                     ldnt1sb.  */
5075                                                  return 2093;
5076                                                }
5077                                              else
5078                                                {
5079                                                  /* 33222222222211111111110000000000
5080                                                     10987654321098765432109876543210
5081                                                     1x0001x0100xxxxx100xxxxxxxxxxxxx
5082                                                     ldnt1sh.  */
5083                                                  return 2094;
5084                                                }
5085                                            }
5086                                          else
5087                                            {
5088                                              if (((word >> 23) & 0x1) == 0)
5089                                                {
5090                                                  if (((word >> 30) & 0x1) == 0)
5091                                                    {
5092                                                      /* 33222222222211111111110000000000
5093                                                         10987654321098765432109876543210
5094                                                         100001x0001xxxxx100xxxxxxxxxxxxx
5095                                                         ld1sb.  */
5096                                                      return 1564;
5097                                                    }
5098                                                  else
5099                                                    {
5100                                                      /* 33222222222211111111110000000000
5101                                                         10987654321098765432109876543210
5102                                                         110001x0001xxxxx100xxxxxxxxxxxxx
5103                                                         ld1sb.  */
5104                                                      return 1568;
5105                                                    }
5106                                                }
5107                                              else
5108                                                {
5109                                                  if (((word >> 30) & 0x1) == 0)
5110                                                    {
5111                                                      /* 33222222222211111111110000000000
5112                                                         10987654321098765432109876543210
5113                                                         100001x0101xxxxx100xxxxxxxxxxxxx
5114                                                         ld1sh.  */
5115                                                      return 1577;
5116                                                    }
5117                                                  else
5118                                                    {
5119                                                      /* 33222222222211111111110000000000
5120                                                         10987654321098765432109876543210
5121                                                         110001x0101xxxxx100xxxxxxxxxxxxx
5122                                                         ld1sh.  */
5123                                                      return 1580;
5124                                                    }
5125                                                }
5126                                            }
5127                                        }
5128                                      else
5129                                        {
5130                                          if (((word >> 23) & 0x1) == 0)
5131                                            {
5132                                              if (((word >> 30) & 0x1) == 0)
5133                                                {
5134                                                  /* 33222222222211111111110000000000
5135                                                     10987654321098765432109876543210
5136                                                     100001x001xxxxxx100xxxxxxxxxxxxx
5137                                                     ld1rb.  */
5138                                                  return 1534;
5139                                                }
5140                                              else
5141                                                {
5142                                                  if (((word >> 21) & 0x1) == 0)
5143                                                    {
5144                                                      /* 33222222222211111111110000000000
5145                                                         10987654321098765432109876543210
5146                                                         110001x0010xxxxx100xxxxxxxxxxxxx
5147                                                         ld1sb.  */
5148                                                      return 1563;
5149                                                    }
5150                                                  else
5151                                                    {
5152                                                      /* 33222222222211111111110000000000
5153                                                         10987654321098765432109876543210
5154                                                         110001x0011xxxxx100xxxxxxxxxxxxx
5155                                                         prfb.  */
5156                                                      return 1766;
5157                                                    }
5158                                                }
5159                                            }
5160                                          else
5161                                            {
5162                                              if (((word >> 30) & 0x1) == 0)
5163                                                {
5164                                                  /* 33222222222211111111110000000000
5165                                                     10987654321098765432109876543210
5166                                                     100001x011xxxxxx100xxxxxxxxxxxxx
5167                                                     ld1rsw.  */
5168                                                  return 1555;
5169                                                }
5170                                              else
5171                                                {
5172                                                  if (((word >> 21) & 0x1) == 0)
5173                                                    {
5174                                                      /* 33222222222211111111110000000000
5175                                                         10987654321098765432109876543210
5176                                                         110001x0110xxxxx100xxxxxxxxxxxxx
5177                                                         ld1sh.  */
5178                                                      return 1575;
5179                                                    }
5180                                                  else
5181                                                    {
5182                                                      /* 33222222222211111111110000000000
5183                                                         10987654321098765432109876543210
5184                                                         110001x0111xxxxx100xxxxxxxxxxxxx
5185                                                         ld1sh.  */
5186                                                      return 1576;
5187                                                    }
5188                                                }
5189                                            }
5190                                        }
5191                                    }
5192                                }
5193                            }
5194                          else
5195                            {
5196                              if (((word >> 15) & 0x1) == 0)
5197                                {
5198                                  if (((word >> 21) & 0x1) == 0)
5199                                    {
5200                                      if (((word >> 30) & 0x1) == 0)
5201                                        {
5202                                          if (((word >> 31) & 0x1) == 0)
5203                                            {
5204                                              /* 33222222222211111111110000000000
5205                                                 10987654321098765432109876543210
5206                                                 000001x0xx0xxxxx010xxxxxxxxxxxxx
5207                                                 mla.  */
5208                                              return 1739;
5209                                            }
5210                                          else
5211                                            {
5212                                              if (((word >> 23) & 0x1) == 0)
5213                                                {
5214                                                  /* 33222222222211111111110000000000
5215                                                     10987654321098765432109876543210
5216                                                     100001x00x0xxxxx010xxxxxxxxxxxxx
5217                                                     ld1b.  */
5218                                                  return 1500;
5219                                                }
5220                                              else
5221                                                {
5222                                                  /* 33222222222211111111110000000000
5223                                                     10987654321098765432109876543210
5224                                                     100001x01x0xxxxx010xxxxxxxxxxxxx
5225                                                     ld1h.  */
5226                                                  return 1520;
5227                                                }
5228                                            }
5229                                        }
5230                                      else
5231                                        {
5232                                          if (((word >> 31) & 0x1) == 0)
5233                                            {
5234                                              if (((word >> 10) & 0x1) == 0)
5235                                                {
5236                                                  if (((word >> 11) & 0x1) == 0)
5237                                                    {
5238                                                      if (((word >> 12) & 0x1) == 0)
5239                                                        {
5240                                                          /* 33222222222211111111110000000000
5241                                                             10987654321098765432109876543210
5242                                                             010001x0xx0xxxxx010000xxxxxxxxxx
5243                                                             smlalb.  */
5244                                                          return 2143;
5245                                                        }
5246                                                      else
5247                                                        {
5248                                                          /* 33222222222211111111110000000000
5249                                                             10987654321098765432109876543210
5250                                                             010001x0xx0xxxxx010100xxxxxxxxxx
5251                                                             smlslb.  */
5252                                                          return 2149;
5253                                                        }
5254                                                    }
5255                                                  else
5256                                                    {
5257                                                      if (((word >> 12) & 0x1) == 0)
5258                                                        {
5259                                                          /* 33222222222211111111110000000000
5260                                                             10987654321098765432109876543210
5261                                                             010001x0xx0xxxxx010010xxxxxxxxxx
5262                                                             umlalb.  */
5263                                                          return 2268;
5264                                                        }
5265                                                      else
5266                                                        {
5267                                                          /* 33222222222211111111110000000000
5268                                                             10987654321098765432109876543210
5269                                                             010001x0xx0xxxxx010110xxxxxxxxxx
5270                                                             umlslb.  */
5271                                                          return 2274;
5272                                                        }
5273                                                    }
5274                                                }
5275                                              else
5276                                                {
5277                                                  if (((word >> 11) & 0x1) == 0)
5278                                                    {
5279                                                      if (((word >> 12) & 0x1) == 0)
5280                                                        {
5281                                                          /* 33222222222211111111110000000000
5282                                                             10987654321098765432109876543210
5283                                                             010001x0xx0xxxxx010001xxxxxxxxxx
5284                                                             smlalt.  */
5285                                                          return 2146;
5286                                                        }
5287                                                      else
5288                                                        {
5289                                                          /* 33222222222211111111110000000000
5290                                                             10987654321098765432109876543210
5291                                                             010001x0xx0xxxxx010101xxxxxxxxxx
5292                                                             smlslt.  */
5293                                                          return 2152;
5294                                                        }
5295                                                    }
5296                                                  else
5297                                                    {
5298                                                      if (((word >> 12) & 0x1) == 0)
5299                                                        {
5300                                                          /* 33222222222211111111110000000000
5301                                                             10987654321098765432109876543210
5302                                                             010001x0xx0xxxxx010011xxxxxxxxxx
5303                                                             umlalt.  */
5304                                                          return 2271;
5305                                                        }
5306                                                      else
5307                                                        {
5308                                                          /* 33222222222211111111110000000000
5309                                                             10987654321098765432109876543210
5310                                                             010001x0xx0xxxxx010111xxxxxxxxxx
5311                                                             umlslt.  */
5312                                                          return 2277;
5313                                                        }
5314                                                    }
5315                                                }
5316                                            }
5317                                          else
5318                                            {
5319                                              if (((word >> 23) & 0x1) == 0)
5320                                                {
5321                                                  /* 33222222222211111111110000000000
5322                                                     10987654321098765432109876543210
5323                                                     110001x00x0xxxxx010xxxxxxxxxxxxx
5324                                                     ld1b.  */
5325                                                  return 1505;
5326                                                }
5327                                              else
5328                                                {
5329                                                  /* 33222222222211111111110000000000
5330                                                     10987654321098765432109876543210
5331                                                     110001x01x0xxxxx010xxxxxxxxxxxxx
5332                                                     ld1h.  */
5333                                                  return 1525;
5334                                                }
5335                                            }
5336                                        }
5337                                    }
5338                                  else
5339                                    {
5340                                      if (((word >> 30) & 0x1) == 0)
5341                                        {
5342                                          if (((word >> 31) & 0x1) == 0)
5343                                            {
5344                                              if (((word >> 11) & 0x1) == 0)
5345                                                {
5346                                                  if (((word >> 12) & 0x1) == 0)
5347                                                    {
5348                                                      if (((word >> 10) & 0x1) == 0)
5349                                                        {
5350                                                          /* 33222222222211111111110000000000
5351                                                             10987654321098765432109876543210
5352                                                             000001x0xx1xxxxx010000xxxxxxxxxx
5353                                                             index.  */
5354                                                          return 1491;
5355                                                        }
5356                                                      else
5357                                                        {
5358                                                          /* 33222222222211111111110000000000
5359                                                             10987654321098765432109876543210
5360                                                             000001x0xx1xxxxx010001xxxxxxxxxx
5361                                                             index.  */
5362                                                          return 1492;
5363                                                        }
5364                                                    }
5365                                                  else
5366                                                    {
5367                                                      if (((word >> 22) & 0x1) == 0)
5368                                                        {
5369                                                          if (((word >> 23) & 0x1) == 0)
5370                                                            {
5371                                                              /* 33222222222211111111110000000000
5372                                                                 10987654321098765432109876543210
5373                                                                 000001x0001xxxxx01010xxxxxxxxxxx
5374                                                                 addvl.  */
5375                                                              return 1278;
5376                                                            }
5377                                                          else
5378                                                            {
5379                                                              /* 33222222222211111111110000000000
5380                                                                 10987654321098765432109876543210
5381                                                                 000001x0101xxxxx01010xxxxxxxxxxx
5382                                                                 rdvl.  */
5383                                                              return 1800;
5384                                                            }
5385                                                        }
5386                                                      else
5387                                                        {
5388                                                          /* 33222222222211111111110000000000
5389                                                             10987654321098765432109876543210
5390                                                             000001x0x11xxxxx01010xxxxxxxxxxx
5391                                                             addpl.  */
5392                                                          return 1277;
5393                                                        }
5394                                                    }
5395                                                }
5396                                              else
5397                                                {
5398                                                  if (((word >> 10) & 0x1) == 0)
5399                                                    {
5400                                                      /* 33222222222211111111110000000000
5401                                                         10987654321098765432109876543210
5402                                                         000001x0xx1xxxxx010x10xxxxxxxxxx
5403                                                         index.  */
5404                                                      return 1493;
5405                                                    }
5406                                                  else
5407                                                    {
5408                                                      /* 33222222222211111111110000000000
5409                                                         10987654321098765432109876543210
5410                                                         000001x0xx1xxxxx010x11xxxxxxxxxx
5411                                                         index.  */
5412                                                      return 1490;
5413                                                    }
5414                                                }
5415                                            }
5416                                          else
5417                                            {
5418                                              if (((word >> 23) & 0x1) == 0)
5419                                                {
5420                                                  /* 33222222222211111111110000000000
5421                                                     10987654321098765432109876543210
5422                                                     100001x00x1xxxxx010xxxxxxxxxxxxx
5423                                                     prfw.  */
5424                                                  return 1784;
5425                                                }
5426                                              else
5427                                                {
5428                                                  /* 33222222222211111111110000000000
5429                                                     10987654321098765432109876543210
5430                                                     100001x01x1xxxxx010xxxxxxxxxxxxx
5431                                                     ld1h.  */
5432                                                  return 1521;
5433                                                }
5434                                            }
5435                                        }
5436                                      else
5437                                        {
5438                                          if (((word >> 23) & 0x1) == 0)
5439                                            {
5440                                              /* 33222222222211111111110000000000
5441                                                 10987654321098765432109876543210
5442                                                 x10001x00x1xxxxx010xxxxxxxxxxxxx
5443                                                 prfw.  */
5444                                              return 1786;
5445                                            }
5446                                          else
5447                                            {
5448                                              if (((word >> 31) & 0x1) == 0)
5449                                                {
5450                                                  if (((word >> 22) & 0x1) == 0)
5451                                                    {
5452                                                      /* 33222222222211111111110000000000
5453                                                         10987654321098765432109876543210
5454                                                         010001x0101xxxxx010xxxxxxxxxxxxx
5455                                                         cdot.  */
5456                                                      return 2058;
5457                                                    }
5458                                                  else
5459                                                    {
5460                                                      /* 33222222222211111111110000000000
5461                                                         10987654321098765432109876543210
5462                                                         010001x0111xxxxx010xxxxxxxxxxxxx
5463                                                         cdot.  */
5464                                                      return 2057;
5465                                                    }
5466                                                }
5467                                              else
5468                                                {
5469                                                  /* 33222222222211111111110000000000
5470                                                     10987654321098765432109876543210
5471                                                     110001x01x1xxxxx010xxxxxxxxxxxxx
5472                                                     ld1h.  */
5473                                                  return 1526;
5474                                                }
5475                                            }
5476                                        }
5477                                    }
5478                                }
5479                              else
5480                                {
5481                                  if (((word >> 30) & 0x1) == 0)
5482                                    {
5483                                      if (((word >> 31) & 0x1) == 0)
5484                                        {
5485                                          if (((word >> 21) & 0x1) == 0)
5486                                            {
5487                                              /* 33222222222211111111110000000000
5488                                                 10987654321098765432109876543210
5489                                                 000001x0xx0xxxxx110xxxxxxxxxxxxx
5490                                                 mad.  */
5491                                              return 1738;
5492                                            }
5493                                          else
5494                                            {
5495                                              if (((word >> 10) & 0x1) == 0)
5496                                                {
5497                                                  if (((word >> 11) & 0x1) == 0)
5498                                                    {
5499                                                      if (((word >> 20) & 0x1) == 0)
5500                                                        {
5501                                                          if (((word >> 22) & 0x1) == 0)
5502                                                            {
5503                                                              /* 33222222222211111111110000000000
5504                                                                 10987654321098765432109876543210
5505                                                                 000001x0x010xxxx110x00xxxxxxxxxx
5506                                                                 sqincw.  */
5507                                                              return 1858;
5508                                                            }
5509                                                          else
5510                                                            {
5511                                                              if (((word >> 23) & 0x1) == 0)
5512                                                                {
5513                                                                  /* 33222222222211111111110000000000
5514                                                                     10987654321098765432109876543210
5515                                                                     000001x00110xxxx110x00xxxxxxxxxx
5516                                                                     sqinch.  */
5517                                                                  return 1852;
5518                                                                }
5519                                                              else
5520                                                                {
5521                                                                  /* 33222222222211111111110000000000
5522                                                                     10987654321098765432109876543210
5523                                                                     000001x01110xxxx110x00xxxxxxxxxx
5524                                                                     sqincd.  */
5525                                                                  return 1849;
5526                                                                }
5527                                                            }
5528                                                        }
5529                                                      else
5530                                                        {
5531                                                          if (((word >> 22) & 0x1) == 0)
5532                                                            {
5533                                                              /* 33222222222211111111110000000000
5534                                                                 10987654321098765432109876543210
5535                                                                 000001x0x011xxxx110x00xxxxxxxxxx
5536                                                                 incw.  */
5537                                                              return 1488;
5538                                                            }
5539                                                          else
5540                                                            {
5541                                                              if (((word >> 23) & 0x1) == 0)
5542                                                                {
5543                                                                  /* 33222222222211111111110000000000
5544                                                                     10987654321098765432109876543210
5545                                                                     000001x00111xxxx110x00xxxxxxxxxx
5546                                                                     inch.  */
5547                                                                  return 1484;
5548                                                                }
5549                                                              else
5550                                                                {
5551                                                                  /* 33222222222211111111110000000000
5552                                                                     10987654321098765432109876543210
5553                                                                     000001x01111xxxx110x00xxxxxxxxxx
5554                                                                     incd.  */
5555                                                                  return 1482;
5556                                                                }
5557                                                            }
5558                                                        }
5559                                                    }
5560                                                  else
5561                                                    {
5562                                                      if (((word >> 22) & 0x1) == 0)
5563                                                        {
5564                                                          /* 33222222222211111111110000000000
5565                                                             10987654321098765432109876543210
5566                                                             000001x0x01xxxxx110x10xxxxxxxxxx
5567                                                             sqdecw.  */
5568                                                          return 1844;
5569                                                        }
5570                                                      else
5571                                                        {
5572                                                          if (((word >> 23) & 0x1) == 0)
5573                                                            {
5574                                                              /* 33222222222211111111110000000000
5575                                                                 10987654321098765432109876543210
5576                                                                 000001x0011xxxxx110x10xxxxxxxxxx
5577                                                                 sqdech.  */
5578                                                              return 1838;
5579                                                            }
5580                                                          else
5581                                                            {
5582                                                              /* 33222222222211111111110000000000
5583                                                                 10987654321098765432109876543210
5584                                                                 000001x0111xxxxx110x10xxxxxxxxxx
5585                                                                 sqdecd.  */
5586                                                              return 1835;
5587                                                            }
5588                                                        }
5589                                                    }
5590                                                }
5591                                              else
5592                                                {
5593                                                  if (((word >> 11) & 0x1) == 0)
5594                                                    {
5595                                                      if (((word >> 20) & 0x1) == 0)
5596                                                        {
5597                                                          if (((word >> 22) & 0x1) == 0)
5598                                                            {
5599                                                              /* 33222222222211111111110000000000
5600                                                                 10987654321098765432109876543210
5601                                                                 000001x0x010xxxx110x01xxxxxxxxxx
5602                                                                 uqincw.  */
5603                                                              return 2006;
5604                                                            }
5605                                                          else
5606                                                            {
5607                                                              if (((word >> 23) & 0x1) == 0)
5608                                                                {
5609                                                                  /* 33222222222211111111110000000000
5610                                                                     10987654321098765432109876543210
5611                                                                     000001x00110xxxx110x01xxxxxxxxxx
5612                                                                     uqinch.  */
5613                                                                  return 2000;
5614                                                                }
5615                                                              else
5616                                                                {
5617                                                                  /* 33222222222211111111110000000000
5618                                                                     10987654321098765432109876543210
5619                                                                     000001x01110xxxx110x01xxxxxxxxxx
5620                                                                     uqincd.  */
5621                                                                  return 1997;
5622                                                                }
5623                                                            }
5624                                                        }
5625                                                      else
5626                                                        {
5627                                                          if (((word >> 22) & 0x1) == 0)
5628                                                            {
5629                                                              /* 33222222222211111111110000000000
5630                                                                 10987654321098765432109876543210
5631                                                                 000001x0x011xxxx110x01xxxxxxxxxx
5632                                                                 decw.  */
5633                                                              return 1363;
5634                                                            }
5635                                                          else
5636                                                            {
5637                                                              if (((word >> 23) & 0x1) == 0)
5638                                                                {
5639                                                                  /* 33222222222211111111110000000000
5640                                                                     10987654321098765432109876543210
5641                                                                     000001x00111xxxx110x01xxxxxxxxxx
5642                                                                     dech.  */
5643                                                                  return 1359;
5644                                                                }
5645                                                              else
5646                                                                {
5647                                                                  /* 33222222222211111111110000000000
5648                                                                     10987654321098765432109876543210
5649                                                                     000001x01111xxxx110x01xxxxxxxxxx
5650                                                                     decd.  */
5651                                                                  return 1357;
5652                                                                }
5653                                                            }
5654                                                        }
5655                                                    }
5656                                                  else
5657                                                    {
5658                                                      if (((word >> 22) & 0x1) == 0)
5659                                                        {
5660                                                          /* 33222222222211111111110000000000
5661                                                             10987654321098765432109876543210
5662                                                             000001x0x01xxxxx110x11xxxxxxxxxx
5663                                                             uqdecw.  */
5664                                                          return 1992;
5665                                                        }
5666                                                      else
5667                                                        {
5668                                                          if (((word >> 23) & 0x1) == 0)
5669                                                            {
5670                                                              /* 33222222222211111111110000000000
5671                                                                 10987654321098765432109876543210
5672                                                                 000001x0011xxxxx110x11xxxxxxxxxx
5673                                                                 uqdech.  */
5674                                                              return 1986;
5675                                                            }
5676                                                          else
5677                                                            {
5678                                                              /* 33222222222211111111110000000000
5679                                                                 10987654321098765432109876543210
5680                                                                 000001x0111xxxxx110x11xxxxxxxxxx
5681                                                                 uqdecd.  */
5682                                                              return 1983;
5683                                                            }
5684                                                        }
5685                                                    }
5686                                                }
5687                                            }
5688                                        }
5689                                      else
5690                                        {
5691                                          if (((word >> 22) & 0x1) == 0)
5692                                            {
5693                                              if (((word >> 21) & 0x1) == 0)
5694                                                {
5695                                                  if (((word >> 23) & 0x1) == 0)
5696                                                    {
5697                                                      /* 33222222222211111111110000000000
5698                                                         10987654321098765432109876543210
5699                                                         100001x0000xxxxx110xxxxxxxxxxxxx
5700                                                         prfb.  */
5701                                                      return 1763;
5702                                                    }
5703                                                  else
5704                                                    {
5705                                                      /* 33222222222211111111110000000000
5706                                                         10987654321098765432109876543210
5707                                                         100001x0100xxxxx110xxxxxxxxxxxxx
5708                                                         prfh.  */
5709                                                      return 1778;
5710                                                    }
5711                                                }
5712                                              else
5713                                                {
5714                                                  if (((word >> 23) & 0x1) == 0)
5715                                                    {
5716                                                      /* 33222222222211111111110000000000
5717                                                         10987654321098765432109876543210
5718                                                         100001x0001xxxxx110xxxxxxxxxxxxx
5719                                                         ld1b.  */
5720                                                      return 1507;
5721                                                    }
5722                                                  else
5723                                                    {
5724                                                      /* 33222222222211111111110000000000
5725                                                         10987654321098765432109876543210
5726                                                         100001x0101xxxxx110xxxxxxxxxxxxx
5727                                                         ld1h.  */
5728                                                      return 1529;
5729                                                    }
5730                                                }
5731                                            }
5732                                          else
5733                                            {
5734                                              if (((word >> 23) & 0x1) == 0)
5735                                                {
5736                                                  /* 33222222222211111111110000000000
5737                                                     10987654321098765432109876543210
5738                                                     100001x001xxxxxx110xxxxxxxxxxxxx
5739                                                     ld1rb.  */
5740                                                  return 1536;
5741                                                }
5742                                              else
5743                                                {
5744                                                  /* 33222222222211111111110000000000
5745                                                     10987654321098765432109876543210
5746                                                     100001x011xxxxxx110xxxxxxxxxxxxx
5747                                                     ld1rh.  */
5748                                                  return 1540;
5749                                                }
5750                                            }
5751                                        }
5752                                    }
5753                                  else
5754                                    {
5755                                      if (((word >> 21) & 0x1) == 0)
5756                                        {
5757                                          if (((word >> 22) & 0x1) == 0)
5758                                            {
5759                                              if (((word >> 23) & 0x1) == 0)
5760                                                {
5761                                                  /* 33222222222211111111110000000000
5762                                                     10987654321098765432109876543210
5763                                                     x10001x0000xxxxx110xxxxxxxxxxxxx
5764                                                     ldnt1b.  */
5765                                                  return 2089;
5766                                                }
5767                                              else
5768                                                {
5769                                                  /* 33222222222211111111110000000000
5770                                                     10987654321098765432109876543210
5771                                                     x10001x0100xxxxx110xxxxxxxxxxxxx
5772                                                     ldnt1h.  */
5773                                                  return 2092;
5774                                                }
5775                                            }
5776                                          else
5777                                            {
5778                                              if (((word >> 23) & 0x1) == 0)
5779                                                {
5780                                                  /* 33222222222211111111110000000000
5781                                                     10987654321098765432109876543210
5782                                                     x10001x0010xxxxx110xxxxxxxxxxxxx
5783                                                     ld1b.  */
5784                                                  return 1506;
5785                                                }
5786                                              else
5787                                                {
5788                                                  /* 33222222222211111111110000000000
5789                                                     10987654321098765432109876543210
5790                                                     x10001x0110xxxxx110xxxxxxxxxxxxx
5791                                                     ld1h.  */
5792                                                  return 1527;
5793                                                }
5794                                            }
5795                                        }
5796                                      else
5797                                        {
5798                                          if (((word >> 22) & 0x1) == 0)
5799                                            {
5800                                              if (((word >> 23) & 0x1) == 0)
5801                                                {
5802                                                  /* 33222222222211111111110000000000
5803                                                     10987654321098765432109876543210
5804                                                     x10001x0001xxxxx110xxxxxxxxxxxxx
5805                                                     ld1b.  */
5806                                                  return 1512;
5807                                                }
5808                                              else
5809                                                {
5810                                                  if (((word >> 31) & 0x1) == 0)
5811                                                    {
5812                                                      if (((word >> 10) & 0x1) == 0)
5813                                                        {
5814                                                          if (((word >> 12) & 0x1) == 0)
5815                                                            {
5816                                                              /* 33222222222211111111110000000000
5817                                                                 10987654321098765432109876543210
5818                                                                 010001x0101xxxxx1100x0xxxxxxxxxx
5819                                                                 smullb.  */
5820                                                              return 2154;
5821                                                            }
5822                                                          else
5823                                                            {
5824                                                              /* 33222222222211111111110000000000
5825                                                                 10987654321098765432109876543210
5826                                                                 010001x0101xxxxx1101x0xxxxxxxxxx
5827                                                                 umullb.  */
5828                                                              return 2279;
5829                                                            }
5830                                                        }
5831                                                      else
5832                                                        {
5833                                                          if (((word >> 12) & 0x1) == 0)
5834                                                            {
5835                                                              /* 33222222222211111111110000000000
5836                                                                 10987654321098765432109876543210
5837                                                                 010001x0101xxxxx1100x1xxxxxxxxxx
5838                                                                 smullt.  */
5839                                                              return 2157;
5840                                                            }
5841                                                          else
5842                                                            {
5843                                                              /* 33222222222211111111110000000000
5844                                                                 10987654321098765432109876543210
5845                                                                 010001x0101xxxxx1101x1xxxxxxxxxx
5846                                                                 umullt.  */
5847                                                              return 2282;
5848                                                            }
5849                                                        }
5850                                                    }
5851                                                  else
5852                                                    {
5853                                                      /* 33222222222211111111110000000000
5854                                                         10987654321098765432109876543210
5855                                                         110001x0101xxxxx110xxxxxxxxxxxxx
5856                                                         ld1h.  */
5857                                                      return 1533;
5858                                                    }
5859                                                }
5860                                            }
5861                                          else
5862                                            {
5863                                              if (((word >> 23) & 0x1) == 0)
5864                                                {
5865                                                  /* 33222222222211111111110000000000
5866                                                     10987654321098765432109876543210
5867                                                     x10001x0011xxxxx110xxxxxxxxxxxxx
5868                                                     prfw.  */
5869                                                  return 1787;
5870                                                }
5871                                              else
5872                                                {
5873                                                  if (((word >> 31) & 0x1) == 0)
5874                                                    {
5875                                                      if (((word >> 10) & 0x1) == 0)
5876                                                        {
5877                                                          if (((word >> 12) & 0x1) == 0)
5878                                                            {
5879                                                              /* 33222222222211111111110000000000
5880                                                                 10987654321098765432109876543210
5881                                                                 010001x0111xxxxx1100x0xxxxxxxxxx
5882                                                                 smullb.  */
5883                                                              return 2155;
5884                                                            }
5885                                                          else
5886                                                            {
5887                                                              /* 33222222222211111111110000000000
5888                                                                 10987654321098765432109876543210
5889                                                                 010001x0111xxxxx1101x0xxxxxxxxxx
5890                                                                 umullb.  */
5891                                                              return 2280;
5892                                                            }
5893                                                        }
5894                                                      else
5895                                                        {
5896                                                          if (((word >> 12) & 0x1) == 0)
5897                                                            {
5898                                                              /* 33222222222211111111110000000000
5899                                                                 10987654321098765432109876543210
5900                                                                 010001x0111xxxxx1100x1xxxxxxxxxx
5901                                                                 smullt.  */
5902                                                              return 2158;
5903                                                            }
5904                                                          else
5905                                                            {
5906                                                              /* 33222222222211111111110000000000
5907                                                                 10987654321098765432109876543210
5908                                                                 010001x0111xxxxx1101x1xxxxxxxxxx
5909                                                                 umullt.  */
5910                                                              return 2283;
5911                                                            }
5912                                                        }
5913                                                    }
5914                                                  else
5915                                                    {
5916                                                      /* 33222222222211111111110000000000
5917                                                         10987654321098765432109876543210
5918                                                         110001x0111xxxxx110xxxxxxxxxxxxx
5919                                                         ld1h.  */
5920                                                      return 1528;
5921                                                    }
5922                                                }
5923                                            }
5924                                        }
5925                                    }
5926                                }
5927                            }
5928                        }
5929                      else
5930                        {
5931                          if (((word >> 14) & 0x1) == 0)
5932                            {
5933                              if (((word >> 15) & 0x1) == 0)
5934                                {
5935                                  if (((word >> 21) & 0x1) == 0)
5936                                    {
5937                                      if (((word >> 30) & 0x1) == 0)
5938                                        {
5939                                          if (((word >> 31) & 0x1) == 0)
5940                                            {
5941                                              if (((word >> 17) & 0x1) == 0)
5942                                                {
5943                                                  if (((word >> 19) & 0x1) == 0)
5944                                                    {
5945                                                      if (((word >> 20) & 0x1) == 0)
5946                                                        {
5947                                                          if (((word >> 16) & 0x1) == 0)
5948                                                            {
5949                                                              /* 33222222222211111111110000000000
5950                                                                 10987654321098765432109876543210
5951                                                                 000001x0xx000x00001xxxxxxxxxxxxx
5952                                                                 saddv.  */
5953                                                              return 1807;
5954                                                            }
5955                                                          else
5956                                                            {
5957                                                              /* 33222222222211111111110000000000
5958                                                                 10987654321098765432109876543210
5959                                                                 000001x0xx000x01001xxxxxxxxxxxxx
5960                                                                 uaddv.  */
5961                                                              return 1959;
5962                                                            }
5963                                                        }
5964                                                      else
5965                                                        {
5966                                                          /* 33222222222211111111110000000000
5967                                                             10987654321098765432109876543210
5968                                                             000001x0xx010x0x001xxxxxxxxxxxxx
5969                                                             movprfx.  */
5970                                                          return 1742;
5971                                                        }
5972                                                    }
5973                                                  else
5974                                                    {
5975                                                      if (((word >> 16) & 0x1) == 0)
5976                                                        {
5977                                                          if (((word >> 20) & 0x1) == 0)
5978                                                            {
5979                                                              /* 33222222222211111111110000000000
5980                                                                 10987654321098765432109876543210
5981                                                                 000001x0xx001x00001xxxxxxxxxxxxx
5982                                                                 smaxv.  */
5983                                                              return 1825;
5984                                                            }
5985                                                          else
5986                                                            {
5987                                                              /* 33222222222211111111110000000000
5988                                                                 10987654321098765432109876543210
5989                                                                 000001x0xx011x00001xxxxxxxxxxxxx
5990                                                                 orv.  */
5991                                                              return 1759;
5992                                                            }
5993                                                        }
5994                                                      else
5995                                                        {
5996                                                          if (((word >> 20) & 0x1) == 0)
5997                                                            {
5998                                                              /* 33222222222211111111110000000000
5999                                                                 10987654321098765432109876543210
6000                                                                 000001x0xx001x01001xxxxxxxxxxxxx
6001                                                                 umaxv.  */
6002                                                              return 1974;
6003                                                            }
6004                                                          else
6005                                                            {
6006                                                              /* 33222222222211111111110000000000
6007                                                                 10987654321098765432109876543210
6008                                                                 000001x0xx011x01001xxxxxxxxxxxxx
6009                                                                 eorv.  */
6010                                                              return 1374;
6011                                                            }
6012                                                        }
6013                                                    }
6014                                                }
6015                                              else
6016                                                {
6017                                                  if (((word >> 16) & 0x1) == 0)
6018                                                    {
6019                                                      if (((word >> 20) & 0x1) == 0)
6020                                                        {
6021                                                          /* 33222222222211111111110000000000
6022                                                             10987654321098765432109876543210
6023                                                             000001x0xx00xx10001xxxxxxxxxxxxx
6024                                                             sminv.  */
6025                                                          return 1828;
6026                                                        }
6027                                                      else
6028                                                        {
6029                                                          /* 33222222222211111111110000000000
6030                                                             10987654321098765432109876543210
6031                                                             000001x0xx01xx10001xxxxxxxxxxxxx
6032                                                             andv.  */
6033                                                          return 1287;
6034                                                        }
6035                                                    }
6036                                                  else
6037                                                    {
6038                                                      /* 33222222222211111111110000000000
6039                                                         10987654321098765432109876543210
6040                                                         000001x0xx0xxx11001xxxxxxxxxxxxx
6041                                                         uminv.  */
6042                                                      return 1977;
6043                                                    }
6044                                                }
6045                                            }
6046                                          else
6047                                            {
6048                                              if (((word >> 23) & 0x1) == 0)
6049                                                {
6050                                                  /* 33222222222211111111110000000000
6051                                                     10987654321098765432109876543210
6052                                                     100001x00x0xxxxx001xxxxxxxxxxxxx
6053                                                     ldff1sb.  */
6054                                                  return 1658;
6055                                                }
6056                                              else
6057                                                {
6058                                                  /* 33222222222211111111110000000000
6059                                                     10987654321098765432109876543210
6060                                                     100001x01x0xxxxx001xxxxxxxxxxxxx
6061                                                     ldff1sh.  */
6062                                                  return 1669;
6063                                                }
6064                                            }
6065                                        }
6066                                      else
6067                                        {
6068                                          if (((word >> 31) & 0x1) == 0)
6069                                            {
6070                                              if (((word >> 12) & 0x1) == 0)
6071                                                {
6072                                                  /* 33222222222211111111110000000000
6073                                                     10987654321098765432109876543210
6074                                                     010001x0xx0xxxxx0010xxxxxxxxxxxx
6075                                                     cmla.  */
6076                                                  return 2059;
6077                                                }
6078                                              else
6079                                                {
6080                                                  /* 33222222222211111111110000000000
6081                                                     10987654321098765432109876543210
6082                                                     010001x0xx0xxxxx0011xxxxxxxxxxxx
6083                                                     sqrdcmlah.  */
6084                                                  return 2191;
6085                                                }
6086                                            }
6087                                          else
6088                                            {
6089                                              if (((word >> 23) & 0x1) == 0)
6090                                                {
6091                                                  /* 33222222222211111111110000000000
6092                                                     10987654321098765432109876543210
6093                                                     110001x00x0xxxxx001xxxxxxxxxxxxx
6094                                                     ldff1sb.  */
6095                                                  return 1665;
6096                                                }
6097                                              else
6098                                                {
6099                                                  /* 33222222222211111111110000000000
6100                                                     10987654321098765432109876543210
6101                                                     110001x01x0xxxxx001xxxxxxxxxxxxx
6102                                                     ldff1sh.  */
6103                                                  return 1675;
6104                                                }
6105                                            }
6106                                        }
6107                                    }
6108                                  else
6109                                    {
6110                                      if (((word >> 30) & 0x1) == 0)
6111                                        {
6112                                          if (((word >> 31) & 0x1) == 0)
6113                                            {
6114                                              if (((word >> 10) & 0x1) == 0)
6115                                                {
6116                                                  if (((word >> 11) & 0x1) == 0)
6117                                                    {
6118                                                      if (((word >> 22) & 0x1) == 0)
6119                                                        {
6120                                                          if (((word >> 23) & 0x1) == 0)
6121                                                            {
6122                                                              /* 33222222222211111111110000000000
6123                                                                 10987654321098765432109876543210
6124                                                                 000001x0001xxxxx001x00xxxxxxxxxx
6125                                                                 and.  */
6126                                                              return 1282;
6127                                                            }
6128                                                          else
6129                                                            {
6130                                                              /* 33222222222211111111110000000000
6131                                                                 10987654321098765432109876543210
6132                                                                 000001x0101xxxxx001x00xxxxxxxxxx
6133                                                                 eor.  */
6134                                                              return 1369;
6135                                                            }
6136                                                        }
6137                                                      else
6138                                                        {
6139                                                          if (((word >> 23) & 0x1) == 0)
6140                                                            {
6141                                                              /* 33222222222211111111110000000000
6142                                                                 10987654321098765432109876543210
6143                                                                 000001x0011xxxxx001x00xxxxxxxxxx
6144                                                                 orr.  */
6145                                                              return 1754;
6146                                                            }
6147                                                          else
6148                                                            {
6149                                                              /* 33222222222211111111110000000000
6150                                                                 10987654321098765432109876543210
6151                                                                 000001x0111xxxxx001x00xxxxxxxxxx
6152                                                                 bic.  */
6153                                                              return 1295;
6154                                                            }
6155                                                        }
6156                                                    }
6157                                                  else
6158                                                    {
6159                                                      if (((word >> 22) & 0x1) == 0)
6160                                                        {
6161                                                          /* 33222222222211111111110000000000
6162                                                             10987654321098765432109876543210
6163                                                             000001x0x01xxxxx001x10xxxxxxxxxx
6164                                                             eor3.  */
6165                                                          return 2062;
6166                                                        }
6167                                                      else
6168                                                        {
6169                                                          /* 33222222222211111111110000000000
6170                                                             10987654321098765432109876543210
6171                                                             000001x0x11xxxxx001x10xxxxxxxxxx
6172                                                             bcax.  */
6173                                                          return 2051;
6174                                                        }
6175                                                    }
6176                                                }
6177                                              else
6178                                                {
6179                                                  if (((word >> 11) & 0x1) == 0)
6180                                                    {
6181                                                      /* 33222222222211111111110000000000
6182                                                         10987654321098765432109876543210
6183                                                         000001x0xx1xxxxx001x01xxxxxxxxxx
6184                                                         xar.  */
6185                                                      return 2324;
6186                                                    }
6187                                                  else
6188                                                    {
6189                                                      if (((word >> 22) & 0x1) == 0)
6190                                                        {
6191                                                          if (((word >> 23) & 0x1) == 0)
6192                                                            {
6193                                                              /* 33222222222211111111110000000000
6194                                                                 10987654321098765432109876543210
6195                                                                 000001x0001xxxxx001x11xxxxxxxxxx
6196                                                                 bsl.  */
6197                                                              return 2052;
6198                                                            }
6199                                                          else
6200                                                            {
6201                                                              /* 33222222222211111111110000000000
6202                                                                 10987654321098765432109876543210
6203                                                                 000001x0101xxxxx001x11xxxxxxxxxx
6204                                                                 bsl2n.  */
6205                                                              return 2054;
6206                                                            }
6207                                                        }
6208                                                      else
6209                                                        {
6210                                                          if (((word >> 23) & 0x1) == 0)
6211                                                            {
6212                                                              /* 33222222222211111111110000000000
6213                                                                 10987654321098765432109876543210
6214                                                                 000001x0011xxxxx001x11xxxxxxxxxx
6215                                                                 bsl1n.  */
6216                                                              return 2053;
6217                                                            }
6218                                                          else
6219                                                            {
6220                                                              /* 33222222222211111111110000000000
6221                                                                 10987654321098765432109876543210
6222                                                                 000001x0111xxxxx001x11xxxxxxxxxx
6223                                                                 nbsl.  */
6224                                                              return 2109;
6225                                                            }
6226                                                        }
6227                                                    }
6228                                                }
6229                                            }
6230                                          else
6231                                            {
6232                                              if (((word >> 23) & 0x1) == 0)
6233                                                {
6234                                                  /* 33222222222211111111110000000000
6235                                                     10987654321098765432109876543210
6236                                                     100001x00x1xxxxx001xxxxxxxxxxxxx
6237                                                     prfh.  */
6238                                                  return 1777;
6239                                                }
6240                                              else
6241                                                {
6242                                                  /* 33222222222211111111110000000000
6243                                                     10987654321098765432109876543210
6244                                                     100001x01x1xxxxx001xxxxxxxxxxxxx
6245                                                     ldff1sh.  */
6246                                                  return 1670;
6247                                                }
6248                                            }
6249                                        }
6250                                      else
6251                                        {
6252                                          if (((word >> 23) & 0x1) == 0)
6253                                            {
6254                                              /* 33222222222211111111110000000000
6255                                                 10987654321098765432109876543210
6256                                                 x10001x00x1xxxxx001xxxxxxxxxxxxx
6257                                                 prfh.  */
6258                                              return 1779;
6259                                            }
6260                                          else
6261                                            {
6262                                              if (((word >> 31) & 0x1) == 0)
6263                                                {
6264                                                  if (((word >> 10) & 0x1) == 0)
6265                                                    {
6266                                                      if (((word >> 12) & 0x1) == 0)
6267                                                        {
6268                                                          if (((word >> 22) & 0x1) == 0)
6269                                                            {
6270                                                              /* 33222222222211111111110000000000
6271                                                                 10987654321098765432109876543210
6272                                                                 010001x0101xxxxx0010x0xxxxxxxxxx
6273                                                                 sqdmlalb.  */
6274                                                              return 2164;
6275                                                            }
6276                                                          else
6277                                                            {
6278                                                              /* 33222222222211111111110000000000
6279                                                                 10987654321098765432109876543210
6280                                                                 010001x0111xxxxx0010x0xxxxxxxxxx
6281                                                                 sqdmlalb.  */
6282                                                              return 2165;
6283                                                            }
6284                                                        }
6285                                                      else
6286                                                        {
6287                                                          if (((word >> 22) & 0x1) == 0)
6288                                                            {
6289                                                              /* 33222222222211111111110000000000
6290                                                                 10987654321098765432109876543210
6291                                                                 010001x0101xxxxx0011x0xxxxxxxxxx
6292                                                                 sqdmlslb.  */
6293                                                              return 2171;
6294                                                            }
6295                                                          else
6296                                                            {
6297                                                              /* 33222222222211111111110000000000
6298                                                                 10987654321098765432109876543210
6299                                                                 010001x0111xxxxx0011x0xxxxxxxxxx
6300                                                                 sqdmlslb.  */
6301                                                              return 2172;
6302                                                            }
6303                                                        }
6304                                                    }
6305                                                  else
6306                                                    {
6307                                                      if (((word >> 12) & 0x1) == 0)
6308                                                        {
6309                                                          if (((word >> 22) & 0x1) == 0)
6310                                                            {
6311                                                              /* 33222222222211111111110000000000
6312                                                                 10987654321098765432109876543210
6313                                                                 010001x0101xxxxx0010x1xxxxxxxxxx
6314                                                                 sqdmlalt.  */
6315                                                              return 2168;
6316                                                            }
6317                                                          else
6318                                                            {
6319                                                              /* 33222222222211111111110000000000
6320                                                                 10987654321098765432109876543210
6321                                                                 010001x0111xxxxx0010x1xxxxxxxxxx
6322                                                                 sqdmlalt.  */
6323                                                              return 2169;
6324                                                            }
6325                                                        }
6326                                                      else
6327                                                        {
6328                                                          if (((word >> 22) & 0x1) == 0)
6329                                                            {
6330                                                              /* 33222222222211111111110000000000
6331                                                                 10987654321098765432109876543210
6332                                                                 010001x0101xxxxx0011x1xxxxxxxxxx
6333                                                                 sqdmlslt.  */
6334                                                              return 2175;
6335                                                            }
6336                                                          else
6337                                                            {
6338                                                              /* 33222222222211111111110000000000
6339                                                                 10987654321098765432109876543210
6340                                                                 010001x0111xxxxx0011x1xxxxxxxxxx
6341                                                                 sqdmlslt.  */
6342                                                              return 2176;
6343                                                            }
6344                                                        }
6345                                                    }
6346                                                }
6347                                              else
6348                                                {
6349                                                  /* 33222222222211111111110000000000
6350                                                     10987654321098765432109876543210
6351                                                     110001x01x1xxxxx001xxxxxxxxxxxxx
6352                                                     ldff1sh.  */
6353                                                  return 1676;
6354                                                }
6355                                            }
6356                                        }
6357                                    }
6358                                }
6359                              else
6360                                {
6361                                  if (((word >> 30) & 0x1) == 0)
6362                                    {
6363                                      if (((word >> 31) & 0x1) == 0)
6364                                        {
6365                                          if (((word >> 21) & 0x1) == 0)
6366                                            {
6367                                              if (((word >> 16) & 0x1) == 0)
6368                                                {
6369                                                  if (((word >> 17) & 0x1) == 0)
6370                                                    {
6371                                                      if (((word >> 18) & 0x1) == 0)
6372                                                        {
6373                                                          if (((word >> 19) & 0x1) == 0)
6374                                                            {
6375                                                              /* 33222222222211111111110000000000
6376                                                                 10987654321098765432109876543210
6377                                                                 000001x0xx0x0000101xxxxxxxxxxxxx
6378                                                                 sxtb.  */
6379                                                              return 1950;
6380                                                            }
6381                                                          else
6382                                                            {
6383                                                              /* 33222222222211111111110000000000
6384                                                                 10987654321098765432109876543210
6385                                                                 000001x0xx0x1000101xxxxxxxxxxxxx
6386                                                                 cls.  */
6387                                                              return 1315;
6388                                                            }
6389                                                        }
6390                                                      else
6391                                                        {
6392                                                          if (((word >> 19) & 0x1) == 0)
6393                                                            {
6394                                                              /* 33222222222211111111110000000000
6395                                                                 10987654321098765432109876543210
6396                                                                 000001x0xx0x0100101xxxxxxxxxxxxx
6397                                                                 sxtw.  */
6398                                                              return 1952;
6399                                                            }
6400                                                          else
6401                                                            {
6402                                                              /* 33222222222211111111110000000000
6403                                                                 10987654321098765432109876543210
6404                                                                 000001x0xx0x1100101xxxxxxxxxxxxx
6405                                                                 fabs.  */
6406                                                              return 1377;
6407                                                            }
6408                                                        }
6409                                                    }
6410                                                  else
6411                                                    {
6412                                                      if (((word >> 18) & 0x1) == 0)
6413                                                        {
6414                                                          if (((word >> 19) & 0x1) == 0)
6415                                                            {
6416                                                              /* 33222222222211111111110000000000
6417                                                                 10987654321098765432109876543210
6418                                                                 000001x0xx0x0010101xxxxxxxxxxxxx
6419                                                                 sxth.  */
6420                                                              return 1951;
6421                                                            }
6422                                                          else
6423                                                            {
6424                                                              /* 33222222222211111111110000000000
6425                                                                 10987654321098765432109876543210
6426                                                                 000001x0xx0x1010101xxxxxxxxxxxxx
6427                                                                 cnt.  */
6428                                                              return 1344;
6429                                                            }
6430                                                        }
6431                                                      else
6432                                                        {
6433                                                          if (((word >> 19) & 0x1) == 0)
6434                                                            {
6435                                                              /* 33222222222211111111110000000000
6436                                                                 10987654321098765432109876543210
6437                                                                 000001x0xx0x0110101xxxxxxxxxxxxx
6438                                                                 abs.  */
6439                                                              return 1273;
6440                                                            }
6441                                                          else
6442                                                            {
6443                                                              /* 33222222222211111111110000000000
6444                                                                 10987654321098765432109876543210
6445                                                                 000001x0xx0x1110101xxxxxxxxxxxxx
6446                                                                 not.  */
6447                                                              return 1751;
6448                                                            }
6449                                                        }
6450                                                    }
6451                                                }
6452                                              else
6453                                                {
6454                                                  if (((word >> 17) & 0x1) == 0)
6455                                                    {
6456                                                      if (((word >> 18) & 0x1) == 0)
6457                                                        {
6458                                                          if (((word >> 19) & 0x1) == 0)
6459                                                            {
6460                                                              /* 33222222222211111111110000000000
6461                                                                 10987654321098765432109876543210
6462                                                                 000001x0xx0x0001101xxxxxxxxxxxxx
6463                                                                 uxtb.  */
6464                                                              return 2013;
6465                                                            }
6466                                                          else
6467                                                            {
6468                                                              /* 33222222222211111111110000000000
6469                                                                 10987654321098765432109876543210
6470                                                                 000001x0xx0x1001101xxxxxxxxxxxxx
6471                                                                 clz.  */
6472                                                              return 1316;
6473                                                            }
6474                                                        }
6475                                                      else
6476                                                        {
6477                                                          if (((word >> 19) & 0x1) == 0)
6478                                                            {
6479                                                              /* 33222222222211111111110000000000
6480                                                                 10987654321098765432109876543210
6481                                                                 000001x0xx0x0101101xxxxxxxxxxxxx
6482                                                                 uxtw.  */
6483                                                              return 2015;
6484                                                            }
6485                                                          else
6486                                                            {
6487                                                              /* 33222222222211111111110000000000
6488                                                                 10987654321098765432109876543210
6489                                                                 000001x0xx0x1101101xxxxxxxxxxxxx
6490                                                                 fneg.  */
6491                                                              return 1454;
6492                                                            }
6493                                                        }
6494                                                    }
6495                                                  else
6496                                                    {
6497                                                      if (((word >> 18) & 0x1) == 0)
6498                                                        {
6499                                                          if (((word >> 19) & 0x1) == 0)
6500                                                            {
6501                                                              /* 33222222222211111111110000000000
6502                                                                 10987654321098765432109876543210
6503                                                                 000001x0xx0x0011101xxxxxxxxxxxxx
6504                                                                 uxth.  */
6505                                                              return 2014;
6506                                                            }
6507                                                          else
6508                                                            {
6509                                                              /* 33222222222211111111110000000000
6510                                                                 10987654321098765432109876543210
6511                                                                 000001x0xx0x1011101xxxxxxxxxxxxx
6512                                                                 cnot.  */
6513                                                              return 1343;
6514                                                            }
6515                                                        }
6516                                                      else
6517                                                        {
6518                                                          /* 33222222222211111111110000000000
6519                                                             10987654321098765432109876543210
6520                                                             000001x0xx0xx111101xxxxxxxxxxxxx
6521                                                             neg.  */
6522                                                          return 1748;
6523                                                        }
6524                                                    }
6525                                                }
6526                                            }
6527                                          else
6528                                            {
6529                                              if (((word >> 12) & 0x1) == 0)
6530                                                {
6531                                                  if (((word >> 23) & 0x1) == 0)
6532                                                    {
6533                                                      if (((word >> 22) & 0x1) == 0)
6534                                                        {
6535                                                          /* 33222222222211111111110000000000
6536                                                             10987654321098765432109876543210
6537                                                             000001x0001xxxxx1010xxxxxxxxxxxx
6538                                                             adr.  */
6539                                                          return 1279;
6540                                                        }
6541                                                      else
6542                                                        {
6543                                                          /* 33222222222211111111110000000000
6544                                                             10987654321098765432109876543210
6545                                                             000001x0011xxxxx1010xxxxxxxxxxxx
6546                                                             adr.  */
6547                                                          return 1280;
6548                                                        }
6549                                                    }
6550                                                  else
6551                                                    {
6552                                                      /* 33222222222211111111110000000000
6553                                                         10987654321098765432109876543210
6554                                                         000001x01x1xxxxx1010xxxxxxxxxxxx
6555                                                         adr.  */
6556                                                      return 1281;
6557                                                    }
6558                                                }
6559                                              else
6560                                                {
6561                                                  if (((word >> 10) & 0x1) == 0)
6562                                                    {
6563                                                      if (((word >> 11) & 0x1) == 0)
6564                                                        {
6565                                                          /* 33222222222211111111110000000000
6566                                                             10987654321098765432109876543210
6567                                                             000001x0xx1xxxxx101100xxxxxxxxxx
6568                                                             ftssel.  */
6569                                                          return 1480;
6570                                                        }
6571                                                      else
6572                                                        {
6573                                                          /* 33222222222211111111110000000000
6574                                                             10987654321098765432109876543210
6575                                                             000001x0xx1xxxxx101110xxxxxxxxxx
6576                                                             fexpa.  */
6577                                                          return 1424;
6578                                                        }
6579                                                    }
6580                                                  else
6581                                                    {
6582                                                      /* 33222222222211111111110000000000
6583                                                         10987654321098765432109876543210
6584                                                         000001x0xx1xxxxx1011x1xxxxxxxxxx
6585                                                         movprfx.  */
6586                                                      return 1741;
6587                                                    }
6588                                                }
6589                                            }
6590                                        }
6591                                      else
6592                                        {
6593                                          if (((word >> 22) & 0x1) == 0)
6594                                            {
6595                                              if (((word >> 21) & 0x1) == 0)
6596                                                {
6597                                                  if (((word >> 23) & 0x1) == 0)
6598                                                    {
6599                                                      /* 33222222222211111111110000000000
6600                                                         10987654321098765432109876543210
6601                                                         100001x0000xxxxx101xxxxxxxxxxxxx
6602                                                         ldnt1b.  */
6603                                                      return 2088;
6604                                                    }
6605                                                  else
6606                                                    {
6607                                                      /* 33222222222211111111110000000000
6608                                                         10987654321098765432109876543210
6609                                                         100001x0100xxxxx101xxxxxxxxxxxxx
6610                                                         ldnt1h.  */
6611                                                      return 2091;
6612                                                    }
6613                                                }
6614                                              else
6615                                                {
6616                                                  if (((word >> 23) & 0x1) == 0)
6617                                                    {
6618                                                      /* 33222222222211111111110000000000
6619                                                         10987654321098765432109876543210
6620                                                         100001x0001xxxxx101xxxxxxxxxxxxx
6621                                                         ldff1sb.  */
6622                                                      return 1667;
6623                                                    }
6624                                                  else
6625                                                    {
6626                                                      /* 33222222222211111111110000000000
6627                                                         10987654321098765432109876543210
6628                                                         100001x0101xxxxx101xxxxxxxxxxxxx
6629                                                         ldff1sh.  */
6630                                                      return 1679;
6631                                                    }
6632                                                }
6633                                            }
6634                                          else
6635                                            {
6636                                              if (((word >> 23) & 0x1) == 0)
6637                                                {
6638                                                  /* 33222222222211111111110000000000
6639                                                     10987654321098765432109876543210
6640                                                     100001x001xxxxxx101xxxxxxxxxxxxx
6641                                                     ld1rb.  */
6642                                                  return 1535;
6643                                                }
6644                                              else
6645                                                {
6646                                                  /* 33222222222211111111110000000000
6647                                                     10987654321098765432109876543210
6648                                                     100001x011xxxxxx101xxxxxxxxxxxxx
6649                                                     ld1rh.  */
6650                                                  return 1539;
6651                                                }
6652                                            }
6653                                        }
6654                                    }
6655                                  else
6656                                    {
6657                                      if (((word >> 21) & 0x1) == 0)
6658                                        {
6659                                          if (((word >> 31) & 0x1) == 0)
6660                                            {
6661                                              if (((word >> 16) & 0x1) == 0)
6662                                                {
6663                                                  if (((word >> 17) & 0x1) == 0)
6664                                                    {
6665                                                      if (((word >> 18) & 0x1) == 0)
6666                                                        {
6667                                                          if (((word >> 19) & 0x1) == 0)
6668                                                            {
6669                                                              /* 33222222222211111111110000000000
6670                                                                 10987654321098765432109876543210
6671                                                                 010001x0xx0x0000101xxxxxxxxxxxxx
6672                                                                 urecpe.  */
6673                                                              return 2299;
6674                                                            }
6675                                                          else
6676                                                            {
6677                                                              /* 33222222222211111111110000000000
6678                                                                 10987654321098765432109876543210
6679                                                                 010001x0xx0x1000101xxxxxxxxxxxxx
6680                                                                 sqabs.  */
6681                                                              return 2161;
6682                                                            }
6683                                                        }
6684                                                      else
6685                                                        {
6686                                                          if (((word >> 20) & 0x1) == 0)
6687                                                            {
6688                                                              /* 33222222222211111111110000000000
6689                                                                 10987654321098765432109876543210
6690                                                                 010001x0xx00x100101xxxxxxxxxxxxx
6691                                                                 sadalp.  */
6692                                                              return 2125;
6693                                                            }
6694                                                          else
6695                                                            {
6696                                                              /* 33222222222211111111110000000000
6697                                                                 10987654321098765432109876543210
6698                                                                 010001x0xx01x100101xxxxxxxxxxxxx
6699                                                                 smaxp.  */
6700                                                              return 2139;
6701                                                            }
6702                                                        }
6703                                                    }
6704                                                  else
6705                                                    {
6706                                                      /* 33222222222211111111110000000000
6707                                                         10987654321098765432109876543210
6708                                                         010001x0xx0xxx10101xxxxxxxxxxxxx
6709                                                         sminp.  */
6710                                                      return 2140;
6711                                                    }
6712                                                }
6713                                              else
6714                                                {
6715                                                  if (((word >> 17) & 0x1) == 0)
6716                                                    {
6717                                                      if (((word >> 18) & 0x1) == 0)
6718                                                        {
6719                                                          if (((word >> 19) & 0x1) == 0)
6720                                                            {
6721                                                              if (((word >> 20) & 0x1) == 0)
6722                                                                {
6723                                                                  /* 33222222222211111111110000000000
6724                                                                     10987654321098765432109876543210
6725                                                                     010001x0xx000001101xxxxxxxxxxxxx
6726                                                                     ursqrte.  */
6727                                                                  return 2304;
6728                                                                }
6729                                                              else
6730                                                                {
6731                                                                  /* 33222222222211111111110000000000
6732                                                                     10987654321098765432109876543210
6733                                                                     010001x0xx010001101xxxxxxxxxxxxx
6734                                                                     addp.  */
6735                                                                  return 2050;
6736                                                                }
6737                                                            }
6738                                                          else
6739                                                            {
6740                                                              /* 33222222222211111111110000000000
6741                                                                 10987654321098765432109876543210
6742                                                                 010001x0xx0x1001101xxxxxxxxxxxxx
6743                                                                 sqneg.  */
6744                                                              return 2188;
6745                                                            }
6746                                                        }
6747                                                      else
6748                                                        {
6749                                                          if (((word >> 20) & 0x1) == 0)
6750                                                            {
6751                                                              /* 33222222222211111111110000000000
6752                                                                 10987654321098765432109876543210
6753                                                                 010001x0xx00x101101xxxxxxxxxxxxx
6754                                                                 uadalp.  */
6755                                                              return 2256;
6756                                                            }
6757                                                          else
6758                                                            {
6759                                                              /* 33222222222211111111110000000000
6760                                                                 10987654321098765432109876543210
6761                                                                 010001x0xx01x101101xxxxxxxxxxxxx
6762                                                                 umaxp.  */
6763                                                              return 2264;
6764                                                            }
6765                                                        }
6766                                                    }
6767                                                  else
6768                                                    {
6769                                                      /* 33222222222211111111110000000000
6770                                                         10987654321098765432109876543210
6771                                                         010001x0xx0xxx11101xxxxxxxxxxxxx
6772                                                         uminp.  */
6773                                                      return 2265;
6774                                                    }
6775                                                }
6776                                            }
6777                                          else
6778                                            {
6779                                              if (((word >> 23) & 0x1) == 0)
6780                                                {
6781                                                  /* 33222222222211111111110000000000
6782                                                     10987654321098765432109876543210
6783                                                     110001x00x0xxxxx101xxxxxxxxxxxxx
6784                                                     ldff1sb.  */
6785                                                  return 1666;
6786                                                }
6787                                              else
6788                                                {
6789                                                  /* 33222222222211111111110000000000
6790                                                     10987654321098765432109876543210
6791                                                     110001x01x0xxxxx101xxxxxxxxxxxxx
6792                                                     ldff1sh.  */
6793                                                  return 1677;
6794                                                }
6795                                            }
6796                                        }
6797                                      else
6798                                        {
6799                                          if (((word >> 22) & 0x1) == 0)
6800                                            {
6801                                              if (((word >> 23) & 0x1) == 0)
6802                                                {
6803                                                  /* 33222222222211111111110000000000
6804                                                     10987654321098765432109876543210
6805                                                     x10001x0001xxxxx101xxxxxxxxxxxxx
6806                                                     ldff1sb.  */
6807                                                  return 1668;
6808                                                }
6809                                              else
6810                                                {
6811                                                  if (((word >> 31) & 0x1) == 0)
6812                                                    {
6813                                                      if (((word >> 10) & 0x1) == 0)
6814                                                        {
6815                                                          if (((word >> 12) & 0x1) == 0)
6816                                                            {
6817                                                              /* 33222222222211111111110000000000
6818                                                                 10987654321098765432109876543210
6819                                                                 010001x0101xxxxx1010x0xxxxxxxxxx
6820                                                                 smlslb.  */
6821                                                              return 2147;
6822                                                            }
6823                                                          else
6824                                                            {
6825                                                              /* 33222222222211111111110000000000
6826                                                                 10987654321098765432109876543210
6827                                                                 010001x0101xxxxx1011x0xxxxxxxxxx
6828                                                                 umlslb.  */
6829                                                              return 2272;
6830                                                            }
6831                                                        }
6832                                                      else
6833                                                        {
6834                                                          if (((word >> 12) & 0x1) == 0)
6835                                                            {
6836                                                              /* 33222222222211111111110000000000
6837                                                                 10987654321098765432109876543210
6838                                                                 010001x0101xxxxx1010x1xxxxxxxxxx
6839                                                                 smlslt.  */
6840                                                              return 2150;
6841                                                            }
6842                                                          else
6843                                                            {
6844                                                              /* 33222222222211111111110000000000
6845                                                                 10987654321098765432109876543210
6846                                                                 010001x0101xxxxx1011x1xxxxxxxxxx
6847                                                                 umlslt.  */
6848                                                              return 2275;
6849                                                            }
6850                                                        }
6851                                                    }
6852                                                  else
6853                                                    {
6854                                                      /* 33222222222211111111110000000000
6855                                                         10987654321098765432109876543210
6856                                                         110001x0101xxxxx101xxxxxxxxxxxxx
6857                                                         ldff1sh.  */
6858                                                      return 1680;
6859                                                    }
6860                                                }
6861                                            }
6862                                          else
6863                                            {
6864                                              if (((word >> 23) & 0x1) == 0)
6865                                                {
6866                                                  /* 33222222222211111111110000000000
6867                                                     10987654321098765432109876543210
6868                                                     x10001x0011xxxxx101xxxxxxxxxxxxx
6869                                                     prfh.  */
6870                                                  return 1780;
6871                                                }
6872                                              else
6873                                                {
6874                                                  if (((word >> 31) & 0x1) == 0)
6875                                                    {
6876                                                      if (((word >> 10) & 0x1) == 0)
6877                                                        {
6878                                                          if (((word >> 12) & 0x1) == 0)
6879                                                            {
6880                                                              /* 33222222222211111111110000000000
6881                                                                 10987654321098765432109876543210
6882                                                                 010001x0111xxxxx1010x0xxxxxxxxxx
6883                                                                 smlslb.  */
6884                                                              return 2148;
6885                                                            }
6886                                                          else
6887                                                            {
6888                                                              /* 33222222222211111111110000000000
6889                                                                 10987654321098765432109876543210
6890                                                                 010001x0111xxxxx1011x0xxxxxxxxxx
6891                                                                 umlslb.  */
6892                                                              return 2273;
6893                                                            }
6894                                                        }
6895                                                      else
6896                                                        {
6897                                                          if (((word >> 12) & 0x1) == 0)
6898                                                            {
6899                                                              /* 33222222222211111111110000000000
6900                                                                 10987654321098765432109876543210
6901                                                                 010001x0111xxxxx1010x1xxxxxxxxxx
6902                                                                 smlslt.  */
6903                                                              return 2151;
6904                                                            }
6905                                                          else
6906                                                            {
6907                                                              /* 33222222222211111111110000000000
6908                                                                 10987654321098765432109876543210
6909                                                                 010001x0111xxxxx1011x1xxxxxxxxxx
6910                                                                 umlslt.  */
6911                                                              return 2276;
6912                                                            }
6913                                                        }
6914                                                    }
6915                                                  else
6916                                                    {
6917                                                      /* 33222222222211111111110000000000
6918                                                         10987654321098765432109876543210
6919                                                         110001x0111xxxxx101xxxxxxxxxxxxx
6920                                                         ldff1sh.  */
6921                                                      return 1678;
6922                                                    }
6923                                                }
6924                                            }
6925                                        }
6926                                    }
6927                                }
6928                            }
6929                          else
6930                            {
6931                              if (((word >> 15) & 0x1) == 0)
6932                                {
6933                                  if (((word >> 21) & 0x1) == 0)
6934                                    {
6935                                      if (((word >> 30) & 0x1) == 0)
6936                                        {
6937                                          if (((word >> 31) & 0x1) == 0)
6938                                            {
6939                                              /* 33222222222211111111110000000000
6940                                                 10987654321098765432109876543210
6941                                                 000001x0xx0xxxxx011xxxxxxxxxxxxx
6942                                                 mls.  */
6943                                              return 1740;
6944                                            }
6945                                          else
6946                                            {
6947                                              if (((word >> 23) & 0x1) == 0)
6948                                                {
6949                                                  /* 33222222222211111111110000000000
6950                                                     10987654321098765432109876543210
6951                                                     100001x00x0xxxxx011xxxxxxxxxxxxx
6952                                                     ldff1b.  */
6953                                                  return 1624;
6954                                                }
6955                                              else
6956                                                {
6957                                                  /* 33222222222211111111110000000000
6958                                                     10987654321098765432109876543210
6959                                                     100001x01x0xxxxx011xxxxxxxxxxxxx
6960                                                     ldff1h.  */
6961                                                  return 1644;
6962                                                }
6963                                            }
6964                                        }
6965                                      else
6966                                        {
6967                                          if (((word >> 31) & 0x1) == 0)
6968                                            {
6969                                              if (((word >> 10) & 0x1) == 0)
6970                                                {
6971                                                  if (((word >> 11) & 0x1) == 0)
6972                                                    {
6973                                                      if (((word >> 12) & 0x1) == 0)
6974                                                        {
6975                                                          /* 33222222222211111111110000000000
6976                                                             10987654321098765432109876543210
6977                                                             010001x0xx0xxxxx011000xxxxxxxxxx
6978                                                             sqdmlalb.  */
6979                                                          return 2166;
6980                                                        }
6981                                                      else
6982                                                        {
6983                                                          /* 33222222222211111111110000000000
6984                                                             10987654321098765432109876543210
6985                                                             010001x0xx0xxxxx011100xxxxxxxxxx
6986                                                             sqrdmlah.  */
6987                                                          return 2195;
6988                                                        }
6989                                                    }
6990                                                  else
6991                                                    {
6992                                                      if (((word >> 12) & 0x1) == 0)
6993                                                        {
6994                                                          /* 33222222222211111111110000000000
6995                                                             10987654321098765432109876543210
6996                                                             010001x0xx0xxxxx011010xxxxxxxxxx
6997                                                             sqdmlslb.  */
6998                                                          return 2173;
6999                                                        }
7000                                                      else
7001                                                        {
7002                                                          /* 33222222222211111111110000000000
7003                                                             10987654321098765432109876543210
7004                                                             010001x0xx0xxxxx011110xxxxxxxxxx
7005                                                             usdot.  */
7006                                                          return 2394;
7007                                                        }
7008                                                    }
7009                                                }
7010                                              else
7011                                                {
7012                                                  if (((word >> 11) & 0x1) == 0)
7013                                                    {
7014                                                      if (((word >> 12) & 0x1) == 0)
7015                                                        {
7016                                                          /* 33222222222211111111110000000000
7017                                                             10987654321098765432109876543210
7018                                                             010001x0xx0xxxxx011001xxxxxxxxxx
7019                                                             sqdmlalt.  */
7020                                                          return 2170;
7021                                                        }
7022                                                      else
7023                                                        {
7024                                                          /* 33222222222211111111110000000000
7025                                                             10987654321098765432109876543210
7026                                                             010001x0xx0xxxxx011101xxxxxxxxxx
7027                                                             sqrdmlsh.  */
7028                                                          return 2199;
7029                                                        }
7030                                                    }
7031                                                  else
7032                                                    {
7033                                                      /* 33222222222211111111110000000000
7034                                                         10987654321098765432109876543210
7035                                                         010001x0xx0xxxxx011x11xxxxxxxxxx
7036                                                         sqdmlslt.  */
7037                                                      return 2177;
7038                                                    }
7039                                                }
7040                                            }
7041                                          else
7042                                            {
7043                                              if (((word >> 23) & 0x1) == 0)
7044                                                {
7045                                                  /* 33222222222211111111110000000000
7046                                                     10987654321098765432109876543210
7047                                                     110001x00x0xxxxx011xxxxxxxxxxxxx
7048                                                     ldff1b.  */
7049                                                  return 1633;
7050                                                }
7051                                              else
7052                                                {
7053                                                  /* 33222222222211111111110000000000
7054                                                     10987654321098765432109876543210
7055                                                     110001x01x0xxxxx011xxxxxxxxxxxxx
7056                                                     ldff1h.  */
7057                                                  return 1652;
7058                                                }
7059                                            }
7060                                        }
7061                                    }
7062                                  else
7063                                    {
7064                                      if (((word >> 30) & 0x1) == 0)
7065                                        {
7066                                          if (((word >> 31) & 0x1) == 0)
7067                                            {
7068                                              if (((word >> 10) & 0x1) == 0)
7069                                                {
7070                                                  if (((word >> 11) & 0x1) == 0)
7071                                                    {
7072                                                      if (((word >> 12) & 0x1) == 0)
7073                                                        {
7074                                                          /* 33222222222211111111110000000000
7075                                                             10987654321098765432109876543210
7076                                                             000001x0xx1xxxxx011000xxxxxxxxxx
7077                                                             mul.  */
7078                                                          return 2108;
7079                                                        }
7080                                                      else
7081                                                        {
7082                                                          /* 33222222222211111111110000000000
7083                                                             10987654321098765432109876543210
7084                                                             000001x0xx1xxxxx011100xxxxxxxxxx
7085                                                             sqdmulh.  */
7086                                                          return 2181;
7087                                                        }
7088                                                    }
7089                                                  else
7090                                                    {
7091                                                      /* 33222222222211111111110000000000
7092                                                         10987654321098765432109876543210
7093                                                         000001x0xx1xxxxx011x10xxxxxxxxxx
7094                                                         smulh.  */
7095                                                      return 2153;
7096                                                    }
7097                                                }
7098                                              else
7099                                                {
7100                                                  if (((word >> 11) & 0x1) == 0)
7101                                                    {
7102                                                      if (((word >> 12) & 0x1) == 0)
7103                                                        {
7104                                                          /* 33222222222211111111110000000000
7105                                                             10987654321098765432109876543210
7106                                                             000001x0xx1xxxxx011001xxxxxxxxxx
7107                                                             pmul.  */
7108                                                          return 2111;
7109                                                        }
7110                                                      else
7111                                                        {
7112                                                          /* 33222222222211111111110000000000
7113                                                             10987654321098765432109876543210
7114                                                             000001x0xx1xxxxx011101xxxxxxxxxx
7115                                                             sqrdmulh.  */
7116                                                          return 2203;
7117                                                        }
7118                                                    }
7119                                                  else
7120                                                    {
7121                                                      /* 33222222222211111111110000000000
7122                                                         10987654321098765432109876543210
7123                                                         000001x0xx1xxxxx011x11xxxxxxxxxx
7124                                                         umulh.  */
7125                                                      return 2278;
7126                                                    }
7127                                                }
7128                                            }
7129                                          else
7130                                            {
7131                                              if (((word >> 23) & 0x1) == 0)
7132                                                {
7133                                                  /* 33222222222211111111110000000000
7134                                                     10987654321098765432109876543210
7135                                                     100001x00x1xxxxx011xxxxxxxxxxxxx
7136                                                     prfd.  */
7137                                                  return 1770;
7138                                                }
7139                                              else
7140                                                {
7141                                                  /* 33222222222211111111110000000000
7142                                                     10987654321098765432109876543210
7143                                                     100001x01x1xxxxx011xxxxxxxxxxxxx
7144                                                     ldff1h.  */
7145                                                  return 1645;
7146                                                }
7147                                            }
7148                                        }
7149                                      else
7150                                        {
7151                                          if (((word >> 23) & 0x1) == 0)
7152                                            {
7153                                              /* 33222222222211111111110000000000
7154                                                 10987654321098765432109876543210
7155                                                 x10001x00x1xxxxx011xxxxxxxxxxxxx
7156                                                 prfd.  */
7157                                              return 1772;
7158                                            }
7159                                          else
7160                                            {
7161                                              if (((word >> 31) & 0x1) == 0)
7162                                                {
7163                                                  if (((word >> 12) & 0x1) == 0)
7164                                                    {
7165                                                      if (((word >> 22) & 0x1) == 0)
7166                                                        {
7167                                                          /* 33222222222211111111110000000000
7168                                                             10987654321098765432109876543210
7169                                                             010001x0101xxxxx0110xxxxxxxxxxxx
7170                                                             cmla.  */
7171                                                          return 2060;
7172                                                        }
7173                                                      else
7174                                                        {
7175                                                          /* 33222222222211111111110000000000
7176                                                             10987654321098765432109876543210
7177                                                             010001x0111xxxxx0110xxxxxxxxxxxx
7178                                                             cmla.  */
7179                                                          return 2061;
7180                                                        }
7181                                                    }
7182                                                  else
7183                                                    {
7184                                                      if (((word >> 22) & 0x1) == 0)
7185                                                        {
7186                                                          /* 33222222222211111111110000000000
7187                                                             10987654321098765432109876543210
7188                                                             010001x0101xxxxx0111xxxxxxxxxxxx
7189                                                             sqrdcmlah.  */
7190                                                          return 2189;
7191                                                        }
7192                                                      else
7193                                                        {
7194                                                          /* 33222222222211111111110000000000
7195                                                             10987654321098765432109876543210
7196                                                             010001x0111xxxxx0111xxxxxxxxxxxx
7197                                                             sqrdcmlah.  */
7198                                                          return 2190;
7199                                                        }
7200                                                    }
7201                                                }
7202                                              else
7203                                                {
7204                                                  /* 33222222222211111111110000000000
7205                                                     10987654321098765432109876543210
7206                                                     110001x01x1xxxxx011xxxxxxxxxxxxx
7207                                                     ldff1h.  */
7208                                                  return 1653;
7209                                                }
7210                                            }
7211                                        }
7212                                    }
7213                                }
7214                              else
7215                                {
7216                                  if (((word >> 30) & 0x1) == 0)
7217                                    {
7218                                      if (((word >> 31) & 0x1) == 0)
7219                                        {
7220                                          if (((word >> 21) & 0x1) == 0)
7221                                            {
7222                                              /* 33222222222211111111110000000000
7223                                                 10987654321098765432109876543210
7224                                                 000001x0xx0xxxxx111xxxxxxxxxxxxx
7225                                                 msb.  */
7226                                              return 1743;
7227                                            }
7228                                          else
7229                                            {
7230                                              if (((word >> 10) & 0x1) == 0)
7231                                                {
7232                                                  if (((word >> 11) & 0x1) == 0)
7233                                                    {
7234                                                      if (((word >> 12) & 0x1) == 0)
7235                                                        {
7236                                                          if (((word >> 20) & 0x1) == 0)
7237                                                            {
7238                                                              if (((word >> 22) & 0x1) == 0)
7239                                                                {
7240                                                                  if (((word >> 23) & 0x1) == 0)
7241                                                                    {
7242                                                                      /* 33222222222211111111110000000000
7243                                                                         10987654321098765432109876543210
7244                                                                         000001x00010xxxx111000xxxxxxxxxx
7245                                                                         cntb.  */
7246                                                                      return 1345;
7247                                                                    }
7248                                                                  else
7249                                                                    {
7250                                                                      /* 33222222222211111111110000000000
7251                                                                         10987654321098765432109876543210
7252                                                                         000001x01010xxxx111000xxxxxxxxxx
7253                                                                         cntw.  */
7254                                                                      return 1349;
7255                                                                    }
7256                                                                }
7257                                                              else
7258                                                                {
7259                                                                  if (((word >> 23) & 0x1) == 0)
7260                                                                    {
7261                                                                      /* 33222222222211111111110000000000
7262                                                                         10987654321098765432109876543210
7263                                                                         000001x00110xxxx111000xxxxxxxxxx
7264                                                                         cnth.  */
7265                                                                      return 1347;
7266                                                                    }
7267                                                                  else
7268                                                                    {
7269                                                                      /* 33222222222211111111110000000000
7270                                                                         10987654321098765432109876543210
7271                                                                         000001x01110xxxx111000xxxxxxxxxx
7272                                                                         cntd.  */
7273                                                                      return 1346;
7274                                                                    }
7275                                                                }
7276                                                            }
7277                                                          else
7278                                                            {
7279                                                              if (((word >> 22) & 0x1) == 0)
7280                                                                {
7281                                                                  if (((word >> 23) & 0x1) == 0)
7282                                                                    {
7283                                                                      /* 33222222222211111111110000000000
7284                                                                         10987654321098765432109876543210
7285                                                                         000001x00011xxxx111000xxxxxxxxxx
7286                                                                         incb.  */
7287                                                                      return 1481;
7288                                                                    }
7289                                                                  else
7290                                                                    {
7291                                                                      /* 33222222222211111111110000000000
7292                                                                         10987654321098765432109876543210
7293                                                                         000001x01011xxxx111000xxxxxxxxxx
7294                                                                         incw.  */
7295                                                                      return 1489;
7296                                                                    }
7297                                                                }
7298                                                              else
7299                                                                {
7300                                                                  if (((word >> 23) & 0x1) == 0)
7301                                                                    {
7302                                                                      /* 33222222222211111111110000000000
7303                                                                         10987654321098765432109876543210
7304                                                                         000001x00111xxxx111000xxxxxxxxxx
7305                                                                         inch.  */
7306                                                                      return 1485;
7307                                                                    }
7308                                                                  else
7309                                                                    {
7310                                                                      /* 33222222222211111111110000000000
7311                                                                         10987654321098765432109876543210
7312                                                                         000001x01111xxxx111000xxxxxxxxxx
7313                                                                         incd.  */
7314                                                                      return 1483;
7315                                                                    }
7316                                                                }
7317                                                            }
7318                                                        }
7319                                                      else
7320                                                        {
7321                                                          if (((word >> 20) & 0x1) == 0)
7322                                                            {
7323                                                              if (((word >> 22) & 0x1) == 0)
7324                                                                {
7325                                                                  if (((word >> 23) & 0x1) == 0)
7326                                                                    {
7327                                                                      /* 33222222222211111111110000000000
7328                                                                         10987654321098765432109876543210
7329                                                                         000001x00010xxxx111100xxxxxxxxxx
7330                                                                         sqincb.  */
7331                                                                      return 1848;
7332                                                                    }
7333                                                                  else
7334                                                                    {
7335                                                                      /* 33222222222211111111110000000000
7336                                                                         10987654321098765432109876543210
7337                                                                         000001x01010xxxx111100xxxxxxxxxx
7338                                                                         sqincw.  */
7339                                                                      return 1860;
7340                                                                    }
7341                                                                }
7342                                                              else
7343                                                                {
7344                                                                  if (((word >> 23) & 0x1) == 0)
7345                                                                    {
7346                                                                      /* 33222222222211111111110000000000
7347                                                                         10987654321098765432109876543210
7348                                                                         000001x00110xxxx111100xxxxxxxxxx
7349                                                                         sqinch.  */
7350                                                                      return 1854;
7351                                                                    }
7352                                                                  else
7353                                                                    {
7354                                                                      /* 33222222222211111111110000000000
7355                                                                         10987654321098765432109876543210
7356                                                                         000001x01110xxxx111100xxxxxxxxxx
7357                                                                         sqincd.  */
7358                                                                      return 1851;
7359                                                                    }
7360                                                                }
7361                                                            }
7362                                                          else
7363                                                            {
7364                                                              if (((word >> 22) & 0x1) == 0)
7365                                                                {
7366                                                                  if (((word >> 23) & 0x1) == 0)
7367                                                                    {
7368                                                                      /* 33222222222211111111110000000000
7369                                                                         10987654321098765432109876543210
7370                                                                         000001x00011xxxx111100xxxxxxxxxx
7371                                                                         sqincb.  */
7372                                                                      return 1847;
7373                                                                    }
7374                                                                  else
7375                                                                    {
7376                                                                      /* 33222222222211111111110000000000
7377                                                                         10987654321098765432109876543210
7378                                                                         000001x01011xxxx111100xxxxxxxxxx
7379                                                                         sqincw.  */
7380                                                                      return 1859;
7381                                                                    }
7382                                                                }
7383                                                              else
7384                                                                {
7385                                                                  if (((word >> 23) & 0x1) == 0)
7386                                                                    {
7387                                                                      /* 33222222222211111111110000000000
7388                                                                         10987654321098765432109876543210
7389                                                                         000001x00111xxxx111100xxxxxxxxxx
7390                                                                         sqinch.  */
7391                                                                      return 1853;
7392                                                                    }
7393                                                                  else
7394                                                                    {
7395                                                                      /* 33222222222211111111110000000000
7396                                                                         10987654321098765432109876543210
7397                                                                         000001x01111xxxx111100xxxxxxxxxx
7398                                                                         sqincd.  */
7399                                                                      return 1850;
7400                                                                    }
7401                                                                }
7402                                                            }
7403                                                        }
7404                                                    }
7405                                                  else
7406                                                    {
7407                                                      if (((word >> 20) & 0x1) == 0)
7408                                                        {
7409                                                          if (((word >> 22) & 0x1) == 0)
7410                                                            {
7411                                                              if (((word >> 23) & 0x1) == 0)
7412                                                                {
7413                                                                  /* 33222222222211111111110000000000
7414                                                                     10987654321098765432109876543210
7415                                                                     000001x00010xxxx111x10xxxxxxxxxx
7416                                                                     sqdecb.  */
7417                                                                  return 1834;
7418                                                                }
7419                                                              else
7420                                                                {
7421                                                                  /* 33222222222211111111110000000000
7422                                                                     10987654321098765432109876543210
7423                                                                     000001x01010xxxx111x10xxxxxxxxxx
7424                                                                     sqdecw.  */
7425                                                                  return 1846;
7426                                                                }
7427                                                            }
7428                                                          else
7429                                                            {
7430                                                              if (((word >> 23) & 0x1) == 0)
7431                                                                {
7432                                                                  /* 33222222222211111111110000000000
7433                                                                     10987654321098765432109876543210
7434                                                                     000001x00110xxxx111x10xxxxxxxxxx
7435                                                                     sqdech.  */
7436                                                                  return 1840;
7437                                                                }
7438                                                              else
7439                                                                {
7440                                                                  /* 33222222222211111111110000000000
7441                                                                     10987654321098765432109876543210
7442                                                                     000001x01110xxxx111x10xxxxxxxxxx
7443                                                                     sqdecd.  */
7444                                                                  return 1837;
7445                                                                }
7446                                                            }
7447                                                        }
7448                                                      else
7449                                                        {
7450                                                          if (((word >> 22) & 0x1) == 0)
7451                                                            {
7452                                                              if (((word >> 23) & 0x1) == 0)
7453                                                                {
7454                                                                  /* 33222222222211111111110000000000
7455                                                                     10987654321098765432109876543210
7456                                                                     000001x00011xxxx111x10xxxxxxxxxx
7457                                                                     sqdecb.  */
7458                                                                  return 1833;
7459                                                                }
7460                                                              else
7461                                                                {
7462                                                                  /* 33222222222211111111110000000000
7463                                                                     10987654321098765432109876543210
7464                                                                     000001x01011xxxx111x10xxxxxxxxxx
7465                                                                     sqdecw.  */
7466                                                                  return 1845;
7467                                                                }
7468                                                            }
7469                                                          else
7470                                                            {
7471                                                              if (((word >> 23) & 0x1) == 0)
7472                                                                {
7473                                                                  /* 33222222222211111111110000000000
7474                                                                     10987654321098765432109876543210
7475                                                                     000001x00111xxxx111x10xxxxxxxxxx
7476                                                                     sqdech.  */
7477                                                                  return 1839;
7478                                                                }
7479                                                              else
7480                                                                {
7481                                                                  /* 33222222222211111111110000000000
7482                                                                     10987654321098765432109876543210
7483                                                                     000001x01111xxxx111x10xxxxxxxxxx
7484                                                                     sqdecd.  */
7485                                                                  return 1836;
7486                                                                }
7487                                                            }
7488                                                        }
7489                                                    }
7490                                                }
7491                                              else
7492                                                {
7493                                                  if (((word >> 11) & 0x1) == 0)
7494                                                    {
7495                                                      if (((word >> 12) & 0x1) == 0)
7496                                                        {
7497                                                          if (((word >> 22) & 0x1) == 0)
7498                                                            {
7499                                                              if (((word >> 23) & 0x1) == 0)
7500                                                                {
7501                                                                  /* 33222222222211111111110000000000
7502                                                                     10987654321098765432109876543210
7503                                                                     000001x0001xxxxx111001xxxxxxxxxx
7504                                                                     decb.  */
7505                                                                  return 1356;
7506                                                                }
7507                                                              else
7508                                                                {
7509                                                                  /* 33222222222211111111110000000000
7510                                                                     10987654321098765432109876543210
7511                                                                     000001x0101xxxxx111001xxxxxxxxxx
7512                                                                     decw.  */
7513                                                                  return 1364;
7514                                                                }
7515                                                            }
7516                                                          else
7517                                                            {
7518                                                              if (((word >> 23) & 0x1) == 0)
7519                                                                {
7520                                                                  /* 33222222222211111111110000000000
7521                                                                     10987654321098765432109876543210
7522                                                                     000001x0011xxxxx111001xxxxxxxxxx
7523                                                                     dech.  */
7524                                                                  return 1360;
7525                                                                }
7526                                                              else
7527                                                                {
7528                                                                  /* 33222222222211111111110000000000
7529                                                                     10987654321098765432109876543210
7530                                                                     000001x0111xxxxx111001xxxxxxxxxx
7531                                                                     decd.  */
7532                                                                  return 1358;
7533                                                                }
7534                                                            }
7535                                                        }
7536                                                      else
7537                                                        {
7538                                                          if (((word >> 20) & 0x1) == 0)
7539                                                            {
7540                                                              if (((word >> 22) & 0x1) == 0)
7541                                                                {
7542                                                                  if (((word >> 23) & 0x1) == 0)
7543                                                                    {
7544                                                                      /* 33222222222211111111110000000000
7545                                                                         10987654321098765432109876543210
7546                                                                         000001x00010xxxx111101xxxxxxxxxx
7547                                                                         uqincb.  */
7548                                                                      return 1995;
7549                                                                    }
7550                                                                  else
7551                                                                    {
7552                                                                      /* 33222222222211111111110000000000
7553                                                                         10987654321098765432109876543210
7554                                                                         000001x01010xxxx111101xxxxxxxxxx
7555                                                                         uqincw.  */
7556                                                                      return 2007;
7557                                                                    }
7558                                                                }
7559                                                              else
7560                                                                {
7561                                                                  if (((word >> 23) & 0x1) == 0)
7562                                                                    {
7563                                                                      /* 33222222222211111111110000000000
7564                                                                         10987654321098765432109876543210
7565                                                                         000001x00110xxxx111101xxxxxxxxxx
7566                                                                         uqinch.  */
7567                                                                      return 2001;
7568                                                                    }
7569                                                                  else
7570                                                                    {
7571                                                                      /* 33222222222211111111110000000000
7572                                                                         10987654321098765432109876543210
7573                                                                         000001x01110xxxx111101xxxxxxxxxx
7574                                                                         uqincd.  */
7575                                                                      return 1998;
7576                                                                    }
7577                                                                }
7578                                                            }
7579                                                          else
7580                                                            {
7581                                                              if (((word >> 22) & 0x1) == 0)
7582                                                                {
7583                                                                  if (((word >> 23) & 0x1) == 0)
7584                                                                    {
7585                                                                      /* 33222222222211111111110000000000
7586                                                                         10987654321098765432109876543210
7587                                                                         000001x00011xxxx111101xxxxxxxxxx
7588                                                                         uqincb.  */
7589                                                                      return 1996;
7590                                                                    }
7591                                                                  else
7592                                                                    {
7593                                                                      /* 33222222222211111111110000000000
7594                                                                         10987654321098765432109876543210
7595                                                                         000001x01011xxxx111101xxxxxxxxxx
7596                                                                         uqincw.  */
7597                                                                      return 2008;
7598                                                                    }
7599                                                                }
7600                                                              else
7601                                                                {
7602                                                                  if (((word >> 23) & 0x1) == 0)
7603                                                                    {
7604                                                                      /* 33222222222211111111110000000000
7605                                                                         10987654321098765432109876543210
7606                                                                         000001x00111xxxx111101xxxxxxxxxx
7607                                                                         uqinch.  */
7608                                                                      return 2002;
7609                                                                    }
7610                                                                  else
7611                                                                    {
7612                                                                      /* 33222222222211111111110000000000
7613                                                                         10987654321098765432109876543210
7614                                                                         000001x01111xxxx111101xxxxxxxxxx
7615                                                                         uqincd.  */
7616                                                                      return 1999;
7617                                                                    }
7618                                                                }
7619                                                            }
7620                                                        }
7621                                                    }
7622                                                  else
7623                                                    {
7624                                                      if (((word >> 20) & 0x1) == 0)
7625                                                        {
7626                                                          if (((word >> 22) & 0x1) == 0)
7627                                                            {
7628                                                              if (((word >> 23) & 0x1) == 0)
7629                                                                {
7630                                                                  /* 33222222222211111111110000000000
7631                                                                     10987654321098765432109876543210
7632                                                                     000001x00010xxxx111x11xxxxxxxxxx
7633                                                                     uqdecb.  */
7634                                                                  return 1981;
7635                                                                }
7636                                                              else
7637                                                                {
7638                                                                  /* 33222222222211111111110000000000
7639                                                                     10987654321098765432109876543210
7640                                                                     000001x01010xxxx111x11xxxxxxxxxx
7641                                                                     uqdecw.  */
7642                                                                  return 1993;
7643                                                                }
7644                                                            }
7645                                                          else
7646                                                            {
7647                                                              if (((word >> 23) & 0x1) == 0)
7648                                                                {
7649                                                                  /* 33222222222211111111110000000000
7650                                                                     10987654321098765432109876543210
7651                                                                     000001x00110xxxx111x11xxxxxxxxxx
7652                                                                     uqdech.  */
7653                                                                  return 1987;
7654                                                                }
7655                                                              else
7656                                                                {
7657                                                                  /* 33222222222211111111110000000000
7658                                                                     10987654321098765432109876543210
7659                                                                     000001x01110xxxx111x11xxxxxxxxxx
7660                                                                     uqdecd.  */
7661                                                                  return 1984;
7662                                                                }
7663                                                            }
7664                                                        }
7665                                                      else
7666                                                        {
7667                                                          if (((word >> 22) & 0x1) == 0)
7668                                                            {
7669                                                              if (((word >> 23) & 0x1) == 0)
7670                                                                {
7671                                                                  /* 33222222222211111111110000000000
7672                                                                     10987654321098765432109876543210
7673                                                                     000001x00011xxxx111x11xxxxxxxxxx
7674                                                                     uqdecb.  */
7675                                                                  return 1982;
7676                                                                }
7677                                                              else
7678                                                                {
7679                                                                  /* 33222222222211111111110000000000
7680                                                                     10987654321098765432109876543210
7681                                                                     000001x01011xxxx111x11xxxxxxxxxx
7682                                                                     uqdecw.  */
7683                                                                  return 1994;
7684                                                                }
7685                                                            }
7686                                                          else
7687                                                            {
7688                                                              if (((word >> 23) & 0x1) == 0)
7689                                                                {
7690                                                                  /* 33222222222211111111110000000000
7691                                                                     10987654321098765432109876543210
7692                                                                     000001x00111xxxx111x11xxxxxxxxxx
7693                                                                     uqdech.  */
7694                                                                  return 1988;
7695                                                                }
7696                                                              else
7697                                                                {
7698                                                                  /* 33222222222211111111110000000000
7699                                                                     10987654321098765432109876543210
7700                                                                     000001x01111xxxx111x11xxxxxxxxxx
7701                                                                     uqdecd.  */
7702                                                                  return 1985;
7703                                                                }
7704                                                            }
7705                                                        }
7706                                                    }
7707                                                }
7708                                            }
7709                                        }
7710                                      else
7711                                        {
7712                                          if (((word >> 22) & 0x1) == 0)
7713                                            {
7714                                              if (((word >> 21) & 0x1) == 0)
7715                                                {
7716                                                  if (((word >> 23) & 0x1) == 0)
7717                                                    {
7718                                                      /* 33222222222211111111110000000000
7719                                                         10987654321098765432109876543210
7720                                                         100001x0000xxxxx111xxxxxxxxxxxxx
7721                                                         prfb.  */
7722                                                      return 1767;
7723                                                    }
7724                                                  else
7725                                                    {
7726                                                      /* 33222222222211111111110000000000
7727                                                         10987654321098765432109876543210
7728                                                         100001x0100xxxxx111xxxxxxxxxxxxx
7729                                                         prfh.  */
7730                                                      return 1781;
7731                                                    }
7732                                                }
7733                                              else
7734                                                {
7735                                                  if (((word >> 23) & 0x1) == 0)
7736                                                    {
7737                                                      /* 33222222222211111111110000000000
7738                                                         10987654321098765432109876543210
7739                                                         100001x0001xxxxx111xxxxxxxxxxxxx
7740                                                         ldff1b.  */
7741                                                      return 1635;
7742                                                    }
7743                                                  else
7744                                                    {
7745                                                      /* 33222222222211111111110000000000
7746                                                         10987654321098765432109876543210
7747                                                         100001x0101xxxxx111xxxxxxxxxxxxx
7748                                                         ldff1h.  */
7749                                                      return 1656;
7750                                                    }
7751                                                }
7752                                            }
7753                                          else
7754                                            {
7755                                              if (((word >> 23) & 0x1) == 0)
7756                                                {
7757                                                  /* 33222222222211111111110000000000
7758                                                     10987654321098765432109876543210
7759                                                     100001x001xxxxxx111xxxxxxxxxxxxx
7760                                                     ld1rb.  */
7761                                                  return 1537;
7762                                                }
7763                                              else
7764                                                {
7765                                                  /* 33222222222211111111110000000000
7766                                                     10987654321098765432109876543210
7767                                                     100001x011xxxxxx111xxxxxxxxxxxxx
7768                                                     ld1rh.  */
7769                                                  return 1541;
7770                                                }
7771                                            }
7772                                        }
7773                                    }
7774                                  else
7775                                    {
7776                                      if (((word >> 21) & 0x1) == 0)
7777                                        {
7778                                          if (((word >> 22) & 0x1) == 0)
7779                                            {
7780                                              if (((word >> 23) & 0x1) == 0)
7781                                                {
7782                                                  /* 33222222222211111111110000000000
7783                                                     10987654321098765432109876543210
7784                                                     x10001x0000xxxxx111xxxxxxxxxxxxx
7785                                                     prfb.  */
7786                                                  return 1769;
7787                                                }
7788                                              else
7789                                                {
7790                                                  /* 33222222222211111111110000000000
7791                                                     10987654321098765432109876543210
7792                                                     x10001x0100xxxxx111xxxxxxxxxxxxx
7793                                                     prfh.  */
7794                                                  return 1783;
7795                                                }
7796                                            }
7797                                          else
7798                                            {
7799                                              if (((word >> 23) & 0x1) == 0)
7800                                                {
7801                                                  /* 33222222222211111111110000000000
7802                                                     10987654321098765432109876543210
7803                                                     x10001x0010xxxxx111xxxxxxxxxxxxx
7804                                                     ldff1b.  */
7805                                                  return 1634;
7806                                                }
7807                                              else
7808                                                {
7809                                                  /* 33222222222211111111110000000000
7810                                                     10987654321098765432109876543210
7811                                                     x10001x0110xxxxx111xxxxxxxxxxxxx
7812                                                     ldff1h.  */
7813                                                  return 1654;
7814                                                }
7815                                            }
7816                                        }
7817                                      else
7818                                        {
7819                                          if (((word >> 23) & 0x1) == 0)
7820                                            {
7821                                              if (((word >> 31) & 0x1) == 0)
7822                                                {
7823                                                  if (((word >> 10) & 0x1) == 0)
7824                                                    {
7825                                                      if (((word >> 11) & 0x1) == 0)
7826                                                        {
7827                                                          /* 33222222222211111111110000000000
7828                                                             10987654321098765432109876543210
7829                                                             010001x00x1xxxxx111x00xxxxxxxxxx
7830                                                             sqdmulh.  */
7831                                                          return 2178;
7832                                                        }
7833                                                      else
7834                                                        {
7835                                                          /* 33222222222211111111110000000000
7836                                                             10987654321098765432109876543210
7837                                                             010001x00x1xxxxx111x10xxxxxxxxxx
7838                                                             mul.  */
7839                                                          return 2105;
7840                                                        }
7841                                                    }
7842                                                  else
7843                                                    {
7844                                                      /* 33222222222211111111110000000000
7845                                                         10987654321098765432109876543210
7846                                                         010001x00x1xxxxx111xx1xxxxxxxxxx
7847                                                         sqrdmulh.  */
7848                                                      return 2200;
7849                                                    }
7850                                                }
7851                                              else
7852                                                {
7853                                                  if (((word >> 22) & 0x1) == 0)
7854                                                    {
7855                                                      /* 33222222222211111111110000000000
7856                                                         10987654321098765432109876543210
7857                                                         110001x0001xxxxx111xxxxxxxxxxxxx
7858                                                         ldff1b.  */
7859                                                      return 1636;
7860                                                    }
7861                                                  else
7862                                                    {
7863                                                      /* 33222222222211111111110000000000
7864                                                         10987654321098765432109876543210
7865                                                         110001x0011xxxxx111xxxxxxxxxxxxx
7866                                                         prfd.  */
7867                                                      return 1773;
7868                                                    }
7869                                                }
7870                                            }
7871                                          else
7872                                            {
7873                                              if (((word >> 22) & 0x1) == 0)
7874                                                {
7875                                                  if (((word >> 31) & 0x1) == 0)
7876                                                    {
7877                                                      if (((word >> 10) & 0x1) == 0)
7878                                                        {
7879                                                          if (((word >> 12) & 0x1) == 0)
7880                                                            {
7881                                                              /* 33222222222211111111110000000000
7882                                                                 10987654321098765432109876543210
7883                                                                 010001x0101xxxxx1110x0xxxxxxxxxx
7884                                                                 sqdmullb.  */
7885                                                              return 2182;
7886                                                            }
7887                                                          else
7888                                                            {
7889                                                              if (((word >> 11) & 0x1) == 0)
7890                                                                {
7891                                                                  /* 33222222222211111111110000000000
7892                                                                     10987654321098765432109876543210
7893                                                                     010001x0101xxxxx111100xxxxxxxxxx
7894                                                                     sqdmulh.  */
7895                                                                  return 2179;
7896                                                                }
7897                                                              else
7898                                                                {
7899                                                                  /* 33222222222211111111110000000000
7900                                                                     10987654321098765432109876543210
7901                                                                     010001x0101xxxxx111110xxxxxxxxxx
7902                                                                     mul.  */
7903                                                                  return 2106;
7904                                                                }
7905                                                            }
7906                                                        }
7907                                                      else
7908                                                        {
7909                                                          if (((word >> 12) & 0x1) == 0)
7910                                                            {
7911                                                              /* 33222222222211111111110000000000
7912                                                                 10987654321098765432109876543210
7913                                                                 010001x0101xxxxx1110x1xxxxxxxxxx
7914                                                                 sqdmullt.  */
7915                                                              return 2185;
7916                                                            }
7917                                                          else
7918                                                            {
7919                                                              /* 33222222222211111111110000000000
7920                                                                 10987654321098765432109876543210
7921                                                                 010001x0101xxxxx1111x1xxxxxxxxxx
7922                                                                 sqrdmulh.  */
7923                                                              return 2201;
7924                                                            }
7925                                                        }
7926                                                    }
7927                                                  else
7928                                                    {
7929                                                      /* 33222222222211111111110000000000
7930                                                         10987654321098765432109876543210
7931                                                         110001x0101xxxxx111xxxxxxxxxxxxx
7932                                                         ldff1h.  */
7933                                                      return 1657;
7934                                                    }
7935                                                }
7936                                              else
7937                                                {
7938                                                  if (((word >> 31) & 0x1) == 0)
7939                                                    {
7940                                                      if (((word >> 10) & 0x1) == 0)
7941                                                        {
7942                                                          if (((word >> 12) & 0x1) == 0)
7943                                                            {
7944                                                              /* 33222222222211111111110000000000
7945                                                                 10987654321098765432109876543210
7946                                                                 010001x0111xxxxx1110x0xxxxxxxxxx
7947                                                                 sqdmullb.  */
7948                                                              return 2183;
7949                                                            }
7950                                                          else
7951                                                            {
7952                                                              if (((word >> 11) & 0x1) == 0)
7953                                                                {
7954                                                                  /* 33222222222211111111110000000000
7955                                                                     10987654321098765432109876543210
7956                                                                     010001x0111xxxxx111100xxxxxxxxxx
7957                                                                     sqdmulh.  */
7958                                                                  return 2180;
7959                                                                }
7960                                                              else
7961                                                                {
7962                                                                  /* 33222222222211111111110000000000
7963                                                                     10987654321098765432109876543210
7964                                                                     010001x0111xxxxx111110xxxxxxxxxx
7965                                                                     mul.  */
7966                                                                  return 2107;
7967                                                                }
7968                                                            }
7969                                                        }
7970                                                      else
7971                                                        {
7972                                                          if (((word >> 12) & 0x1) == 0)
7973                                                            {
7974                                                              /* 33222222222211111111110000000000
7975                                                                 10987654321098765432109876543210
7976                                                                 010001x0111xxxxx1110x1xxxxxxxxxx
7977                                                                 sqdmullt.  */
7978                                                              return 2186;
7979                                                            }
7980                                                          else
7981                                                            {
7982                                                              /* 33222222222211111111110000000000
7983                                                                 10987654321098765432109876543210
7984                                                                 010001x0111xxxxx1111x1xxxxxxxxxx
7985                                                                 sqrdmulh.  */
7986                                                              return 2202;
7987                                                            }
7988                                                        }
7989                                                    }
7990                                                  else
7991                                                    {
7992                                                      /* 33222222222211111111110000000000
7993                                                         10987654321098765432109876543210
7994                                                         110001x0111xxxxx111xxxxxxxxxxxxx
7995                                                         ldff1h.  */
7996                                                      return 1655;
7997                                                    }
7998                                                }
7999                                            }
8000                                        }
8001                                    }
8002                                }
8003                            }
8004                        }
8005                    }
8006                  else
8007                    {
8008                      if (((word >> 21) & 0x1) == 0)
8009                        {
8010                          if (((word >> 15) & 0x1) == 0)
8011                            {
8012                              if (((word >> 30) & 0x1) == 0)
8013                                {
8014                                  if (((word >> 13) & 0x1) == 0)
8015                                    {
8016                                      if (((word >> 14) & 0x1) == 0)
8017                                        {
8018                                          if (((word >> 31) & 0x1) == 0)
8019                                            {
8020                                              if (((word >> 4) & 0x1) == 0)
8021                                                {
8022                                                  /* 33222222222211111111110000000000
8023                                                     10987654321098765432109876543210
8024                                                     001001x0xx0xxxxx000xxxxxxxx0xxxx
8025                                                     cmphs.  */
8026                                                  return 1329;
8027                                                }
8028                                              else
8029                                                {
8030                                                  /* 33222222222211111111110000000000
8031                                                     10987654321098765432109876543210
8032                                                     001001x0xx0xxxxx000xxxxxxxx1xxxx
8033                                                     cmphi.  */
8034                                                  return 1326;
8035                                                }
8036                                            }
8037                                          else
8038                                            {
8039                                              if (((word >> 23) & 0x1) == 0)
8040                                                {
8041                                                  /* 33222222222211111111110000000000
8042                                                     10987654321098765432109876543210
8043                                                     101001x00x0xxxxx000xxxxxxxxxxxxx
8044                                                     ld1rqb.  */
8045                                                  return 1543;
8046                                                }
8047                                              else
8048                                                {
8049                                                  /* 33222222222211111111110000000000
8050                                                     10987654321098765432109876543210
8051                                                     101001x01x0xxxxx000xxxxxxxxxxxxx
8052                                                     ld1rqh.  */
8053                                                  return 1547;
8054                                                }
8055                                            }
8056                                        }
8057                                      else
8058                                        {
8059                                          if (((word >> 31) & 0x1) == 0)
8060                                            {
8061                                              if (((word >> 4) & 0x1) == 0)
8062                                                {
8063                                                  /* 33222222222211111111110000000000
8064                                                     10987654321098765432109876543210
8065                                                     001001x0xx0xxxxx010xxxxxxxx0xxxx
8066                                                     cmpge.  */
8067                                                  return 1320;
8068                                                }
8069                                              else
8070                                                {
8071                                                  /* 33222222222211111111110000000000
8072                                                     10987654321098765432109876543210
8073                                                     001001x0xx0xxxxx010xxxxxxxx1xxxx
8074                                                     cmpgt.  */
8075                                                  return 1323;
8076                                                }
8077                                            }
8078                                          else
8079                                            {
8080                                              if (((word >> 22) & 0x1) == 0)
8081                                                {
8082                                                  if (((word >> 23) & 0x1) == 0)
8083                                                    {
8084                                                      /* 33222222222211111111110000000000
8085                                                         10987654321098765432109876543210
8086                                                         101001x0000xxxxx010xxxxxxxxxxxxx
8087                                                         ld1b.  */
8088                                                      return 1501;
8089                                                    }
8090                                                  else
8091                                                    {
8092                                                      /* 33222222222211111111110000000000
8093                                                         10987654321098765432109876543210
8094                                                         101001x0100xxxxx010xxxxxxxxxxxxx
8095                                                         ld1sw.  */
8096                                                      return 1581;
8097                                                    }
8098                                                }
8099                                              else
8100                                                {
8101                                                  if (((word >> 23) & 0x1) == 0)
8102                                                    {
8103                                                      /* 33222222222211111111110000000000
8104                                                         10987654321098765432109876543210
8105                                                         101001x0010xxxxx010xxxxxxxxxxxxx
8106                                                         ld1b.  */
8107                                                      return 1503;
8108                                                    }
8109                                                  else
8110                                                    {
8111                                                      /* 33222222222211111111110000000000
8112                                                         10987654321098765432109876543210
8113                                                         101001x0110xxxxx010xxxxxxxxxxxxx
8114                                                         ld1h.  */
8115                                                      return 1523;
8116                                                    }
8117                                                }
8118                                            }
8119                                        }
8120                                    }
8121                                  else
8122                                    {
8123                                      if (((word >> 14) & 0x1) == 0)
8124                                        {
8125                                          if (((word >> 31) & 0x1) == 0)
8126                                            {
8127                                              if (((word >> 4) & 0x1) == 0)
8128                                                {
8129                                                  /* 33222222222211111111110000000000
8130                                                     10987654321098765432109876543210
8131                                                     001001x0xx0xxxxx001xxxxxxxx0xxxx
8132                                                     cmpeq.  */
8133                                                  return 1317;
8134                                                }
8135                                              else
8136                                                {
8137                                                  /* 33222222222211111111110000000000
8138                                                     10987654321098765432109876543210
8139                                                     001001x0xx0xxxxx001xxxxxxxx1xxxx
8140                                                     cmpne.  */
8141                                                  return 1340;
8142                                                }
8143                                            }
8144                                          else
8145                                            {
8146                                              if (((word >> 23) & 0x1) == 0)
8147                                                {
8148                                                  /* 33222222222211111111110000000000
8149                                                     10987654321098765432109876543210
8150                                                     101001x00x0xxxxx001xxxxxxxxxxxxx
8151                                                     ld1rqb.  */
8152                                                  return 1542;
8153                                                }
8154                                              else
8155                                                {
8156                                                  /* 33222222222211111111110000000000
8157                                                     10987654321098765432109876543210
8158                                                     101001x01x0xxxxx001xxxxxxxxxxxxx
8159                                                     ld1rqh.  */
8160                                                  return 1546;
8161                                                }
8162                                            }
8163                                        }
8164                                      else
8165                                        {
8166                                          if (((word >> 31) & 0x1) == 0)
8167                                            {
8168                                              if (((word >> 4) & 0x1) == 0)
8169                                                {
8170                                                  /* 33222222222211111111110000000000
8171                                                     10987654321098765432109876543210
8172                                                     001001x0xx0xxxxx011xxxxxxxx0xxxx
8173                                                     cmplt.  */
8174                                                  return 1338;
8175                                                }
8176                                              else
8177                                                {
8178                                                  /* 33222222222211111111110000000000
8179                                                     10987654321098765432109876543210
8180                                                     001001x0xx0xxxxx011xxxxxxxx1xxxx
8181                                                     cmple.  */
8182                                                  return 1332;
8183                                                }
8184                                            }
8185                                          else
8186                                            {
8187                                              if (((word >> 22) & 0x1) == 0)
8188                                                {
8189                                                  if (((word >> 23) & 0x1) == 0)
8190                                                    {
8191                                                      /* 33222222222211111111110000000000
8192                                                         10987654321098765432109876543210
8193                                                         101001x0000xxxxx011xxxxxxxxxxxxx
8194                                                         ldff1b.  */
8195                                                      return 1625;
8196                                                    }
8197                                                  else
8198                                                    {
8199                                                      /* 33222222222211111111110000000000
8200                                                         10987654321098765432109876543210
8201                                                         101001x0100xxxxx011xxxxxxxxxxxxx
8202                                                         ldff1sw.  */
8203                                                      return 1681;
8204                                                    }
8205                                                }
8206                                              else
8207                                                {
8208                                                  if (((word >> 23) & 0x1) == 0)
8209                                                    {
8210                                                      /* 33222222222211111111110000000000
8211                                                         10987654321098765432109876543210
8212                                                         101001x0010xxxxx011xxxxxxxxxxxxx
8213                                                         ldff1b.  */
8214                                                      return 1629;
8215                                                    }
8216                                                  else
8217                                                    {
8218                                                      /* 33222222222211111111110000000000
8219                                                         10987654321098765432109876543210
8220                                                         101001x0110xxxxx011xxxxxxxxxxxxx
8221                                                         ldff1h.  */
8222                                                      return 1648;
8223                                                    }
8224                                                }
8225                                            }
8226                                        }
8227                                    }
8228                                }
8229                              else
8230                                {
8231                                  if (((word >> 31) & 0x1) == 0)
8232                                    {
8233                                      /* 33222222222211111111110000000000
8234                                         10987654321098765432109876543210
8235                                         011001x0xx0xxxxx0xxxxxxxxxxxxxxx
8236                                         fcmla.  */
8237                                      return 1386;
8238                                    }
8239                                  else
8240                                    {
8241                                      if (((word >> 13) & 0x1) == 0)
8242                                        {
8243                                          if (((word >> 22) & 0x1) == 0)
8244                                            {
8245                                              /* 33222222222211111111110000000000
8246                                                 10987654321098765432109876543210
8247                                                 111001x0x00xxxxx0x0xxxxxxxxxxxxx
8248                                                 st1b.  */
8249                                              return 1863;
8250                                            }
8251                                          else
8252                                            {
8253                                              if (((word >> 23) & 0x1) == 0)
8254                                                {
8255                                                  /* 33222222222211111111110000000000
8256                                                     10987654321098765432109876543210
8257                                                     111001x0010xxxxx0x0xxxxxxxxxxxxx
8258                                                     st1b.  */
8259                                                  return 1867;
8260                                                }
8261                                              else
8262                                                {
8263                                                  /* 33222222222211111111110000000000
8264                                                     10987654321098765432109876543210
8265                                                     111001x0110xxxxx0x0xxxxxxxxxxxxx
8266                                                     st1h.  */
8267                                                  return 1888;
8268                                                }
8269                                            }
8270                                        }
8271                                      else
8272                                        {
8273                                          if (((word >> 14) & 0x1) == 0)
8274                                            {
8275                                              if (((word >> 22) & 0x1) == 0)
8276                                                {
8277                                                  if (((word >> 23) & 0x1) == 0)
8278                                                    {
8279                                                      /* 33222222222211111111110000000000
8280                                                         10987654321098765432109876543210
8281                                                         111001x0000xxxxx001xxxxxxxxxxxxx
8282                                                         stnt1b.  */
8283                                                      return 2240;
8284                                                    }
8285                                                  else
8286                                                    {
8287                                                      /* 33222222222211111111110000000000
8288                                                         10987654321098765432109876543210
8289                                                         111001x0100xxxxx001xxxxxxxxxxxxx
8290                                                         stnt1h.  */
8291                                                      return 2243;
8292                                                    }
8293                                                }
8294                                              else
8295                                                {
8296                                                  if (((word >> 23) & 0x1) == 0)
8297                                                    {
8298                                                      /* 33222222222211111111110000000000
8299                                                         10987654321098765432109876543210
8300                                                         111001x0010xxxxx001xxxxxxxxxxxxx
8301                                                         stnt1b.  */
8302                                                      return 2239;
8303                                                    }
8304                                                  else
8305                                                    {
8306                                                      /* 33222222222211111111110000000000
8307                                                         10987654321098765432109876543210
8308                                                         111001x0110xxxxx001xxxxxxxxxxxxx
8309                                                         stnt1h.  */
8310                                                      return 2242;
8311                                                    }
8312                                                }
8313                                            }
8314                                          else
8315                                            {
8316                                              if (((word >> 22) & 0x1) == 0)
8317                                                {
8318                                                  if (((word >> 23) & 0x1) == 0)
8319                                                    {
8320                                                      /* 33222222222211111111110000000000
8321                                                         10987654321098765432109876543210
8322                                                         111001x0000xxxxx011xxxxxxxxxxxxx
8323                                                         stnt1b.  */
8324                                                      return 1933;
8325                                                    }
8326                                                  else
8327                                                    {
8328                                                      /* 33222222222211111111110000000000
8329                                                         10987654321098765432109876543210
8330                                                         111001x0100xxxxx011xxxxxxxxxxxxx
8331                                                         stnt1h.  */
8332                                                      return 1937;
8333                                                    }
8334                                                }
8335                                              else
8336                                                {
8337                                                  if (((word >> 23) & 0x1) == 0)
8338                                                    {
8339                                                      /* 33222222222211111111110000000000
8340                                                         10987654321098765432109876543210
8341                                                         111001x0010xxxxx011xxxxxxxxxxxxx
8342                                                         st3b.  */
8343                                                      return 1917;
8344                                                    }
8345                                                  else
8346                                                    {
8347                                                      /* 33222222222211111111110000000000
8348                                                         10987654321098765432109876543210
8349                                                         111001x0110xxxxx011xxxxxxxxxxxxx
8350                                                         st3h.  */
8351                                                      return 1921;
8352                                                    }
8353                                                }
8354                                            }
8355                                        }
8356                                    }
8357                                }
8358                            }
8359                          else
8360                            {
8361                              if (((word >> 13) & 0x1) == 0)
8362                                {
8363                                  if (((word >> 30) & 0x1) == 0)
8364                                    {
8365                                      if (((word >> 14) & 0x1) == 0)
8366                                        {
8367                                          if (((word >> 4) & 0x1) == 0)
8368                                            {
8369                                              /* 33222222222211111111110000000000
8370                                                 10987654321098765432109876543210
8371                                                 x01001x0xx0xxxxx100xxxxxxxx0xxxx
8372                                                 cmpge.  */
8373                                              return 1321;
8374                                            }
8375                                          else
8376                                            {
8377                                              /* 33222222222211111111110000000000
8378                                                 10987654321098765432109876543210
8379                                                 x01001x0xx0xxxxx100xxxxxxxx1xxxx
8380                                                 cmpgt.  */
8381                                              return 1324;
8382                                            }
8383                                        }
8384                                      else
8385                                        {
8386                                          if (((word >> 31) & 0x1) == 0)
8387                                            {
8388                                              if (((word >> 4) & 0x1) == 0)
8389                                                {
8390                                                  /* 33222222222211111111110000000000
8391                                                     10987654321098765432109876543210
8392                                                     001001x0xx0xxxxx110xxxxxxxx0xxxx
8393                                                     cmphs.  */
8394                                                  return 1330;
8395                                                }
8396                                              else
8397                                                {
8398                                                  /* 33222222222211111111110000000000
8399                                                     10987654321098765432109876543210
8400                                                     001001x0xx0xxxxx110xxxxxxxx1xxxx
8401                                                     cmphi.  */
8402                                                  return 1327;
8403                                                }
8404                                            }
8405                                          else
8406                                            {
8407                                              if (((word >> 22) & 0x1) == 0)
8408                                                {
8409                                                  if (((word >> 23) & 0x1) == 0)
8410                                                    {
8411                                                      /* 33222222222211111111110000000000
8412                                                         10987654321098765432109876543210
8413                                                         101001x0000xxxxx110xxxxxxxxxxxxx
8414                                                         ldnt1b.  */
8415                                                      return 1716;
8416                                                    }
8417                                                  else
8418                                                    {
8419                                                      /* 33222222222211111111110000000000
8420                                                         10987654321098765432109876543210
8421                                                         101001x0100xxxxx110xxxxxxxxxxxxx
8422                                                         ldnt1h.  */
8423                                                      return 1720;
8424                                                    }
8425                                                }
8426                                              else
8427                                                {
8428                                                  if (((word >> 23) & 0x1) == 0)
8429                                                    {
8430                                                      /* 33222222222211111111110000000000
8431                                                         10987654321098765432109876543210
8432                                                         101001x0010xxxxx110xxxxxxxxxxxxx
8433                                                         ld3b.  */
8434                                                      return 1608;
8435                                                    }
8436                                                  else
8437                                                    {
8438                                                      /* 33222222222211111111110000000000
8439                                                         10987654321098765432109876543210
8440                                                         101001x0110xxxxx110xxxxxxxxxxxxx
8441                                                         ld3h.  */
8442                                                      return 1612;
8443                                                    }
8444                                                }
8445                                            }
8446                                        }
8447                                    }
8448                                  else
8449                                    {
8450                                      if (((word >> 31) & 0x1) == 0)
8451                                        {
8452                                          if (((word >> 17) & 0x1) == 0)
8453                                            {
8454                                              if (((word >> 18) & 0x1) == 0)
8455                                                {
8456                                                  if (((word >> 20) & 0x1) == 0)
8457                                                    {
8458                                                      /* 33222222222211111111110000000000
8459                                                         10987654321098765432109876543210
8460                                                         011001x0xx00x00x1x0xxxxxxxxxxxxx
8461                                                         fcadd.  */
8462                                                      return 1385;
8463                                                    }
8464                                                  else
8465                                                    {
8466                                                      /* 33222222222211111111110000000000
8467                                                         10987654321098765432109876543210
8468                                                         011001x0xx01x00x1x0xxxxxxxxxxxxx
8469                                                         faddp.  */
8470                                                      return 2066;
8471                                                    }
8472                                                }
8473                                              else
8474                                                {
8475                                                  if (((word >> 16) & 0x1) == 0)
8476                                                    {
8477                                                      /* 33222222222211111111110000000000
8478                                                         10987654321098765432109876543210
8479                                                         011001x0xx0xx1001x0xxxxxxxxxxxxx
8480                                                         fmaxnmp.  */
8481                                                      return 2074;
8482                                                    }
8483                                                  else
8484                                                    {
8485                                                      /* 33222222222211111111110000000000
8486                                                         10987654321098765432109876543210
8487                                                         011001x0xx0xx1011x0xxxxxxxxxxxxx
8488                                                         fminnmp.  */
8489                                                      return 2076;
8490                                                    }
8491                                                }
8492                                            }
8493                                          else
8494                                            {
8495                                              if (((word >> 16) & 0x1) == 0)
8496                                                {
8497                                                  /* 33222222222211111111110000000000
8498                                                     10987654321098765432109876543210
8499                                                     011001x0xx0xxx101x0xxxxxxxxxxxxx
8500                                                     fmaxp.  */
8501                                                  return 2075;
8502                                                }
8503                                              else
8504                                                {
8505                                                  /* 33222222222211111111110000000000
8506                                                     10987654321098765432109876543210
8507                                                     011001x0xx0xxx111x0xxxxxxxxxxxxx
8508                                                     fminp.  */
8509                                                  return 2077;
8510                                                }
8511                                            }
8512                                        }
8513                                      else
8514                                        {
8515                                          if (((word >> 22) & 0x1) == 0)
8516                                            {
8517                                              if (((word >> 23) & 0x1) == 0)
8518                                                {
8519                                                  /* 33222222222211111111110000000000
8520                                                     10987654321098765432109876543210
8521                                                     111001x0000xxxxx1x0xxxxxxxxxxxxx
8522                                                     st1b.  */
8523                                                  return 1864;
8524                                                }
8525                                              else
8526                                                {
8527                                                  /* 33222222222211111111110000000000
8528                                                     10987654321098765432109876543210
8529                                                     111001x0100xxxxx1x0xxxxxxxxxxxxx
8530                                                     st1h.  */
8531                                                  return 1883;
8532                                                }
8533                                            }
8534                                          else
8535                                            {
8536                                              if (((word >> 23) & 0x1) == 0)
8537                                                {
8538                                                  /* 33222222222211111111110000000000
8539                                                     10987654321098765432109876543210
8540                                                     111001x0010xxxxx1x0xxxxxxxxxxxxx
8541                                                     st1b.  */
8542                                                  return 1868;
8543                                                }
8544                                              else
8545                                                {
8546                                                  /* 33222222222211111111110000000000
8547                                                     10987654321098765432109876543210
8548                                                     111001x0110xxxxx1x0xxxxxxxxxxxxx
8549                                                     st1h.  */
8550                                                  return 1889;
8551                                                }
8552                                            }
8553                                        }
8554                                    }
8555                                }
8556                              else
8557                                {
8558                                  if (((word >> 14) & 0x1) == 0)
8559                                    {
8560                                      if (((word >> 30) & 0x1) == 0)
8561                                        {
8562                                          if (((word >> 31) & 0x1) == 0)
8563                                            {
8564                                              if (((word >> 4) & 0x1) == 0)
8565                                                {
8566                                                  /* 33222222222211111111110000000000
8567                                                     10987654321098765432109876543210
8568                                                     001001x0xx0xxxxx101xxxxxxxx0xxxx
8569                                                     cmpeq.  */
8570                                                  return 1318;
8571                                                }
8572                                              else
8573                                                {
8574                                                  /* 33222222222211111111110000000000
8575                                                     10987654321098765432109876543210
8576                                                     001001x0xx0xxxxx101xxxxxxxx1xxxx
8577                                                     cmpne.  */
8578                                                  return 1341;
8579                                                }
8580                                            }
8581                                          else
8582                                            {
8583                                              if (((word >> 20) & 0x1) == 0)
8584                                                {
8585                                                  if (((word >> 22) & 0x1) == 0)
8586                                                    {
8587                                                      if (((word >> 23) & 0x1) == 0)
8588                                                        {
8589                                                          /* 33222222222211111111110000000000
8590                                                             10987654321098765432109876543210
8591                                                             101001x00000xxxx101xxxxxxxxxxxxx
8592                                                             ld1b.  */
8593                                                          return 1508;
8594                                                        }
8595                                                      else
8596                                                        {
8597                                                          /* 33222222222211111111110000000000
8598                                                             10987654321098765432109876543210
8599                                                             101001x01000xxxx101xxxxxxxxxxxxx
8600                                                             ld1sw.  */
8601                                                          return 1586;
8602                                                        }
8603                                                    }
8604                                                  else
8605                                                    {
8606                                                      if (((word >> 23) & 0x1) == 0)
8607                                                        {
8608                                                          /* 33222222222211111111110000000000
8609                                                             10987654321098765432109876543210
8610                                                             101001x00100xxxx101xxxxxxxxxxxxx
8611                                                             ld1b.  */
8612                                                          return 1510;
8613                                                        }
8614                                                      else
8615                                                        {
8616                                                          /* 33222222222211111111110000000000
8617                                                             10987654321098765432109876543210
8618                                                             101001x01100xxxx101xxxxxxxxxxxxx
8619                                                             ld1h.  */
8620                                                          return 1531;
8621                                                        }
8622                                                    }
8623                                                }
8624                                              else
8625                                                {
8626                                                  if (((word >> 22) & 0x1) == 0)
8627                                                    {
8628                                                      if (((word >> 23) & 0x1) == 0)
8629                                                        {
8630                                                          /* 33222222222211111111110000000000
8631                                                             10987654321098765432109876543210
8632                                                             101001x00001xxxx101xxxxxxxxxxxxx
8633                                                             ldnf1b.  */
8634                                                          return 1700;
8635                                                        }
8636                                                      else
8637                                                        {
8638                                                          /* 33222222222211111111110000000000
8639                                                             10987654321098765432109876543210
8640                                                             101001x01001xxxx101xxxxxxxxxxxxx
8641                                                             ldnf1sw.  */
8642                                                          return 1713;
8643                                                        }
8644                                                    }
8645                                                  else
8646                                                    {
8647                                                      if (((word >> 23) & 0x1) == 0)
8648                                                        {
8649                                                          /* 33222222222211111111110000000000
8650                                                             10987654321098765432109876543210
8651                                                             101001x00101xxxx101xxxxxxxxxxxxx
8652                                                             ldnf1b.  */
8653                                                          return 1702;
8654                                                        }
8655                                                      else
8656                                                        {
8657                                                          /* 33222222222211111111110000000000
8658                                                             10987654321098765432109876543210
8659                                                             101001x01101xxxx101xxxxxxxxxxxxx
8660                                                             ldnf1h.  */
8661                                                          return 1706;
8662                                                        }
8663                                                    }
8664                                                }
8665                                            }
8666                                        }
8667                                      else
8668                                        {
8669                                          if (((word >> 22) & 0x1) == 0)
8670                                            {
8671                                              if (((word >> 23) & 0x1) == 0)
8672                                                {
8673                                                  if (((word >> 31) & 0x1) == 0)
8674                                                    {
8675                                                      /* 33222222222211111111110000000000
8676                                                         10987654321098765432109876543210
8677                                                         011001x0000xxxxx101xxxxxxxxxxxxx
8678                                                         fcvtxnt.  */
8679                                                      return 2072;
8680                                                    }
8681                                                  else
8682                                                    {
8683                                                      /* 33222222222211111111110000000000
8684                                                         10987654321098765432109876543210
8685                                                         111001x0000xxxxx101xxxxxxxxxxxxx
8686                                                         st1b.  */
8687                                                      return 1865;
8688                                                    }
8689                                                }
8690                                              else
8691                                                {
8692                                                  if (((word >> 31) & 0x1) == 0)
8693                                                    {
8694                                                      if (((word >> 16) & 0x1) == 0)
8695                                                        {
8696                                                          if (((word >> 17) & 0x1) == 0)
8697                                                            {
8698                                                              /* 33222222222211111111110000000000
8699                                                                 10987654321098765432109876543210
8700                                                                 011001x0100xxx00101xxxxxxxxxxxxx
8701                                                                 fcvtnt.  */
8702                                                              return 2069;
8703                                                            }
8704                                                          else
8705                                                            {
8706                                                              /* 33222222222211111111110000000000
8707                                                                 10987654321098765432109876543210
8708                                                                 011001x0100xxx10101xxxxxxxxxxxxx
8709                                                                 bfcvtnt.  */
8710                                                              return 2423;
8711                                                            }
8712                                                        }
8713                                                      else
8714                                                        {
8715                                                          /* 33222222222211111111110000000000
8716                                                             10987654321098765432109876543210
8717                                                             011001x0100xxxx1101xxxxxxxxxxxxx
8718                                                             fcvtlt.  */
8719                                                          return 2067;
8720                                                        }
8721                                                    }
8722                                                  else
8723                                                    {
8724                                                      /* 33222222222211111111110000000000
8725                                                         10987654321098765432109876543210
8726                                                         111001x0100xxxxx101xxxxxxxxxxxxx
8727                                                         st1h.  */
8728                                                      return 1884;
8729                                                    }
8730                                                }
8731                                            }
8732                                          else
8733                                            {
8734                                              if (((word >> 23) & 0x1) == 0)
8735                                                {
8736                                                  /* 33222222222211111111110000000000
8737                                                     10987654321098765432109876543210
8738                                                     x11001x0010xxxxx101xxxxxxxxxxxxx
8739                                                     st1b.  */
8740                                                  return 1872;
8741                                                }
8742                                              else
8743                                                {
8744                                                  if (((word >> 31) & 0x1) == 0)
8745                                                    {
8746                                                      if (((word >> 16) & 0x1) == 0)
8747                                                        {
8748                                                          /* 33222222222211111111110000000000
8749                                                             10987654321098765432109876543210
8750                                                             011001x0110xxxx0101xxxxxxxxxxxxx
8751                                                             fcvtnt.  */
8752                                                          return 2070;
8753                                                        }
8754                                                      else
8755                                                        {
8756                                                          /* 33222222222211111111110000000000
8757                                                             10987654321098765432109876543210
8758                                                             011001x0110xxxx1101xxxxxxxxxxxxx
8759                                                             fcvtlt.  */
8760                                                          return 2068;
8761                                                        }
8762                                                    }
8763                                                  else
8764                                                    {
8765                                                      /* 33222222222211111111110000000000
8766                                                         10987654321098765432109876543210
8767                                                         111001x0110xxxxx101xxxxxxxxxxxxx
8768                                                         st1h.  */
8769                                                      return 1893;
8770                                                    }
8771                                                }
8772                                            }
8773                                        }
8774                                    }
8775                                  else
8776                                    {
8777                                      if (((word >> 30) & 0x1) == 0)
8778                                        {
8779                                          if (((word >> 31) & 0x1) == 0)
8780                                            {
8781                                              if (((word >> 4) & 0x1) == 0)
8782                                                {
8783                                                  /* 33222222222211111111110000000000
8784                                                     10987654321098765432109876543210
8785                                                     001001x0xx0xxxxx111xxxxxxxx0xxxx
8786                                                     cmplo.  */
8787                                                  return 1334;
8788                                                }
8789                                              else
8790                                                {
8791                                                  /* 33222222222211111111110000000000
8792                                                     10987654321098765432109876543210
8793                                                     001001x0xx0xxxxx111xxxxxxxx1xxxx
8794                                                     cmpls.  */
8795                                                  return 1336;
8796                                                }
8797                                            }
8798                                          else
8799                                            {
8800                                              if (((word >> 22) & 0x1) == 0)
8801                                                {
8802                                                  if (((word >> 23) & 0x1) == 0)
8803                                                    {
8804                                                      /* 33222222222211111111110000000000
8805                                                         10987654321098765432109876543210
8806                                                         101001x0000xxxxx111xxxxxxxxxxxxx
8807                                                         ldnt1b.  */
8808                                                      return 1717;
8809                                                    }
8810                                                  else
8811                                                    {
8812                                                      /* 33222222222211111111110000000000
8813                                                         10987654321098765432109876543210
8814                                                         101001x0100xxxxx111xxxxxxxxxxxxx
8815                                                         ldnt1h.  */
8816                                                      return 1721;
8817                                                    }
8818                                                }
8819                                              else
8820                                                {
8821                                                  if (((word >> 23) & 0x1) == 0)
8822                                                    {
8823                                                      /* 33222222222211111111110000000000
8824                                                         10987654321098765432109876543210
8825                                                         101001x0010xxxxx111xxxxxxxxxxxxx
8826                                                         ld3b.  */
8827                                                      return 1609;
8828                                                    }
8829                                                  else
8830                                                    {
8831                                                      /* 33222222222211111111110000000000
8832                                                         10987654321098765432109876543210
8833                                                         101001x0110xxxxx111xxxxxxxxxxxxx
8834                                                         ld3h.  */
8835                                                      return 1613;
8836                                                    }
8837                                                }
8838                                            }
8839                                        }
8840                                      else
8841                                        {
8842                                          if (((word >> 20) & 0x1) == 0)
8843                                            {
8844                                              if (((word >> 22) & 0x1) == 0)
8845                                                {
8846                                                  /* 33222222222211111111110000000000
8847                                                     10987654321098765432109876543210
8848                                                     x11001x0x000xxxx111xxxxxxxxxxxxx
8849                                                     st1b.  */
8850                                                  return 1870;
8851                                                }
8852                                              else
8853                                                {
8854                                                  if (((word >> 23) & 0x1) == 0)
8855                                                    {
8856                                                      /* 33222222222211111111110000000000
8857                                                         10987654321098765432109876543210
8858                                                         x11001x00100xxxx111xxxxxxxxxxxxx
8859                                                         st1b.  */
8860                                                      return 1873;
8861                                                    }
8862                                                  else
8863                                                    {
8864                                                      /* 33222222222211111111110000000000
8865                                                         10987654321098765432109876543210
8866                                                         x11001x01100xxxx111xxxxxxxxxxxxx
8867                                                         st1h.  */
8868                                                      return 1894;
8869                                                    }
8870                                                }
8871                                            }
8872                                          else
8873                                            {
8874                                              if (((word >> 22) & 0x1) == 0)
8875                                                {
8876                                                  if (((word >> 23) & 0x1) == 0)
8877                                                    {
8878                                                      /* 33222222222211111111110000000000
8879                                                         10987654321098765432109876543210
8880                                                         x11001x00001xxxx111xxxxxxxxxxxxx
8881                                                         stnt1b.  */
8882                                                      return 1934;
8883                                                    }
8884                                                  else
8885                                                    {
8886                                                      /* 33222222222211111111110000000000
8887                                                         10987654321098765432109876543210
8888                                                         x11001x01001xxxx111xxxxxxxxxxxxx
8889                                                         stnt1h.  */
8890                                                      return 1938;
8891                                                    }
8892                                                }
8893                                              else
8894                                                {
8895                                                  if (((word >> 23) & 0x1) == 0)
8896                                                    {
8897                                                      /* 33222222222211111111110000000000
8898                                                         10987654321098765432109876543210
8899                                                         x11001x00101xxxx111xxxxxxxxxxxxx
8900                                                         st3b.  */
8901                                                      return 1918;
8902                                                    }
8903                                                  else
8904                                                    {
8905                                                      /* 33222222222211111111110000000000
8906                                                         10987654321098765432109876543210
8907                                                         x11001x01101xxxx111xxxxxxxxxxxxx
8908                                                         st3h.  */
8909                                                      return 1922;
8910                                                    }
8911                                                }
8912                                            }
8913                                        }
8914                                    }
8915                                }
8916                            }
8917                        }
8918                      else
8919                        {
8920                          if (((word >> 13) & 0x1) == 0)
8921                            {
8922                              if (((word >> 30) & 0x1) == 0)
8923                                {
8924                                  if (((word >> 31) & 0x1) == 0)
8925                                    {
8926                                      if (((word >> 4) & 0x1) == 0)
8927                                        {
8928                                          /* 33222222222211111111110000000000
8929                                             10987654321098765432109876543210
8930                                             001001x0xx1xxxxxxx0xxxxxxxx0xxxx
8931                                             cmphs.  */
8932                                          return 1331;
8933                                        }
8934                                      else
8935                                        {
8936                                          /* 33222222222211111111110000000000
8937                                             10987654321098765432109876543210
8938                                             001001x0xx1xxxxxxx0xxxxxxxx1xxxx
8939                                             cmphi.  */
8940                                          return 1328;
8941                                        }
8942                                    }
8943                                  else
8944                                    {
8945                                      if (((word >> 14) & 0x1) == 0)
8946                                        {
8947                                          if (((word >> 23) & 0x1) == 0)
8948                                            {
8949                                              /* 33222222222211111111110000000000
8950                                                 10987654321098765432109876543210
8951                                                 101001x00x1xxxxxx00xxxxxxxxxxxxx
8952                                                 ld1rob.  */
8953                                              return 2399;
8954                                            }
8955                                          else
8956                                            {
8957                                              /* 33222222222211111111110000000000
8958                                                 10987654321098765432109876543210
8959                                                 101001x01x1xxxxxx00xxxxxxxxxxxxx
8960                                                 ld1roh.  */
8961                                              return 2400;
8962                                            }
8963                                        }
8964                                      else
8965                                        {
8966                                          if (((word >> 15) & 0x1) == 0)
8967                                            {
8968                                              if (((word >> 22) & 0x1) == 0)
8969                                                {
8970                                                  if (((word >> 23) & 0x1) == 0)
8971                                                    {
8972                                                      /* 33222222222211111111110000000000
8973                                                         10987654321098765432109876543210
8974                                                         101001x0001xxxxx010xxxxxxxxxxxxx
8975                                                         ld1b.  */
8976                                                      return 1502;
8977                                                    }
8978                                                  else
8979                                                    {
8980                                                      /* 33222222222211111111110000000000
8981                                                         10987654321098765432109876543210
8982                                                         101001x0101xxxxx010xxxxxxxxxxxxx
8983                                                         ld1h.  */
8984                                                      return 1522;
8985                                                    }
8986                                                }
8987                                              else
8988                                                {
8989                                                  if (((word >> 23) & 0x1) == 0)
8990                                                    {
8991                                                      /* 33222222222211111111110000000000
8992                                                         10987654321098765432109876543210
8993                                                         101001x0011xxxxx010xxxxxxxxxxxxx
8994                                                         ld1b.  */
8995                                                      return 1504;
8996                                                    }
8997                                                  else
8998                                                    {
8999                                                      /* 33222222222211111111110000000000
9000                                                         10987654321098765432109876543210
9001                                                         101001x0111xxxxx010xxxxxxxxxxxxx
9002                                                         ld1h.  */
9003                                                      return 1524;
9004                                                    }
9005                                                }
9006                                            }
9007                                          else
9008                                            {
9009                                              if (((word >> 22) & 0x1) == 0)
9010                                                {
9011                                                  if (((word >> 23) & 0x1) == 0)
9012                                                    {
9013                                                      /* 33222222222211111111110000000000
9014                                                         10987654321098765432109876543210
9015                                                         101001x0001xxxxx110xxxxxxxxxxxxx
9016                                                         ld2b.  */
9017                                                      return 1600;
9018                                                    }
9019                                                  else
9020                                                    {
9021                                                      /* 33222222222211111111110000000000
9022                                                         10987654321098765432109876543210
9023                                                         101001x0101xxxxx110xxxxxxxxxxxxx
9024                                                         ld2h.  */
9025                                                      return 1604;
9026                                                    }
9027                                                }
9028                                              else
9029                                                {
9030                                                  if (((word >> 23) & 0x1) == 0)
9031                                                    {
9032                                                      /* 33222222222211111111110000000000
9033                                                         10987654321098765432109876543210
9034                                                         101001x0011xxxxx110xxxxxxxxxxxxx
9035                                                         ld4b.  */
9036                                                      return 1616;
9037                                                    }
9038                                                  else
9039                                                    {
9040                                                      /* 33222222222211111111110000000000
9041                                                         10987654321098765432109876543210
9042                                                         101001x0111xxxxx110xxxxxxxxxxxxx
9043                                                         ld4h.  */
9044                                                      return 1620;
9045                                                    }
9046                                                }
9047                                            }
9048                                        }
9049                                    }
9050                                }
9051                              else
9052                                {
9053                                  if (((word >> 15) & 0x1) == 0)
9054                                    {
9055                                      if (((word >> 14) & 0x1) == 0)
9056                                        {
9057                                          if (((word >> 12) & 0x1) == 0)
9058                                            {
9059                                              if (((word >> 10) & 0x1) == 0)
9060                                                {
9061                                                  if (((word >> 23) & 0x1) == 0)
9062                                                    {
9063                                                      /* 33222222222211111111110000000000
9064                                                         10987654321098765432109876543210
9065                                                         x11001x00x1xxxxx0000x0xxxxxxxxxx
9066                                                         fmla.  */
9067                                                      return 1439;
9068                                                    }
9069                                                  else
9070                                                    {
9071                                                      if (((word >> 22) & 0x1) == 0)
9072                                                        {
9073                                                          /* 33222222222211111111110000000000
9074                                                             10987654321098765432109876543210
9075                                                             x11001x0101xxxxx0000x0xxxxxxxxxx
9076                                                             fmla.  */
9077                                                          return 1440;
9078                                                        }
9079                                                      else
9080                                                        {
9081                                                          /* 33222222222211111111110000000000
9082                                                             10987654321098765432109876543210
9083                                                             x11001x0111xxxxx0000x0xxxxxxxxxx
9084                                                             fmla.  */
9085                                                          return 1441;
9086                                                        }
9087                                                    }
9088                                                }
9089                                              else
9090                                                {
9091                                                  if (((word >> 23) & 0x1) == 0)
9092                                                    {
9093                                                      /* 33222222222211111111110000000000
9094                                                         10987654321098765432109876543210
9095                                                         x11001x00x1xxxxx0000x1xxxxxxxxxx
9096                                                         fmls.  */
9097                                                      return 1443;
9098                                                    }
9099                                                  else
9100                                                    {
9101                                                      if (((word >> 22) & 0x1) == 0)
9102                                                        {
9103                                                          /* 33222222222211111111110000000000
9104                                                             10987654321098765432109876543210
9105                                                             x11001x0101xxxxx0000x1xxxxxxxxxx
9106                                                             fmls.  */
9107                                                          return 1444;
9108                                                        }
9109                                                      else
9110                                                        {
9111                                                          /* 33222222222211111111110000000000
9112                                                             10987654321098765432109876543210
9113                                                             x11001x0111xxxxx0000x1xxxxxxxxxx
9114                                                             fmls.  */
9115                                                          return 1445;
9116                                                        }
9117                                                    }
9118                                                }
9119                                            }
9120                                          else
9121                                            {
9122                                              if (((word >> 22) & 0x1) == 0)
9123                                                {
9124                                                  /* 33222222222211111111110000000000
9125                                                     10987654321098765432109876543210
9126                                                     x11001x0x01xxxxx0001xxxxxxxxxxxx
9127                                                     fcmla.  */
9128                                                  return 1387;
9129                                                }
9130                                              else
9131                                                {
9132                                                  /* 33222222222211111111110000000000
9133                                                     10987654321098765432109876543210
9134                                                     x11001x0x11xxxxx0001xxxxxxxxxxxx
9135                                                     fcmla.  */
9136                                                  return 1388;
9137                                                }
9138                                            }
9139                                        }
9140                                      else
9141                                        {
9142                                          if (((word >> 22) & 0x1) == 0)
9143                                            {
9144                                              if (((word >> 23) & 0x1) == 0)
9145                                                {
9146                                                  /* 33222222222211111111110000000000
9147                                                     10987654321098765432109876543210
9148                                                     x11001x0001xxxxx010xxxxxxxxxxxxx
9149                                                     st1b.  */
9150                                                  return 1866;
9151                                                }
9152                                              else
9153                                                {
9154                                                  if (((word >> 31) & 0x1) == 0)
9155                                                    {
9156                                                      if (((word >> 10) & 0x1) == 0)
9157                                                        {
9158                                                          /* 33222222222211111111110000000000
9159                                                             10987654321098765432109876543210
9160                                                             011001x0101xxxxx010xx0xxxxxxxxxx
9161                                                             fmlalb.  */
9162                                                          return 2078;
9163                                                        }
9164                                                      else
9165                                                        {
9166                                                          /* 33222222222211111111110000000000
9167                                                             10987654321098765432109876543210
9168                                                             011001x0101xxxxx010xx1xxxxxxxxxx
9169                                                             fmlalt.  */
9170                                                          return 2080;
9171                                                        }
9172                                                    }
9173                                                  else
9174                                                    {
9175                                                      /* 33222222222211111111110000000000
9176                                                         10987654321098765432109876543210
9177                                                         111001x0101xxxxx010xxxxxxxxxxxxx
9178                                                         st1h.  */
9179                                                      return 1885;
9180                                                    }
9181                                                }
9182                                            }
9183                                          else
9184                                            {
9185                                              if (((word >> 23) & 0x1) == 0)
9186                                                {
9187                                                  if (((word >> 31) & 0x1) == 0)
9188                                                    {
9189                                                      /* 33222222222211111111110000000000
9190                                                         10987654321098765432109876543210
9191                                                         011001x0011xxxxx010xxxxxxxxxxxxx
9192                                                         bfdot.  */
9193                                                      return 2420;
9194                                                    }
9195                                                  else
9196                                                    {
9197                                                      /* 33222222222211111111110000000000
9198                                                         10987654321098765432109876543210
9199                                                         111001x0011xxxxx010xxxxxxxxxxxxx
9200                                                         st1b.  */
9201                                                      return 1869;
9202                                                    }
9203                                                }
9204                                              else
9205                                                {
9206                                                  if (((word >> 31) & 0x1) == 0)
9207                                                    {
9208                                                      if (((word >> 10) & 0x1) == 0)
9209                                                        {
9210                                                          /* 33222222222211111111110000000000
9211                                                             10987654321098765432109876543210
9212                                                             011001x0111xxxxx010xx0xxxxxxxxxx
9213                                                             bfmlalb.  */
9214                                                          return 2427;
9215                                                        }
9216                                                      else
9217                                                        {
9218                                                          /* 33222222222211111111110000000000
9219                                                             10987654321098765432109876543210
9220                                                             011001x0111xxxxx010xx1xxxxxxxxxx
9221                                                             bfmlalt.  */
9222                                                          return 2426;
9223                                                        }
9224                                                    }
9225                                                  else
9226                                                    {
9227                                                      /* 33222222222211111111110000000000
9228                                                         10987654321098765432109876543210
9229                                                         111001x0111xxxxx010xxxxxxxxxxxxx
9230                                                         st1h.  */
9231                                                      return 1890;
9232                                                    }
9233                                                }
9234                                            }
9235                                        }
9236                                    }
9237                                  else
9238                                    {
9239                                      if (((word >> 22) & 0x1) == 0)
9240                                        {
9241                                          if (((word >> 31) & 0x1) == 0)
9242                                            {
9243                                              if (((word >> 10) & 0x1) == 0)
9244                                                {
9245                                                  /* 33222222222211111111110000000000
9246                                                     10987654321098765432109876543210
9247                                                     011001x0x01xxxxx1x0xx0xxxxxxxxxx
9248                                                     fmlalb.  */
9249                                                  return 2079;
9250                                                }
9251                                              else
9252                                                {
9253                                                  /* 33222222222211111111110000000000
9254                                                     10987654321098765432109876543210
9255                                                     011001x0x01xxxxx1x0xx1xxxxxxxxxx
9256                                                     fmlalt.  */
9257                                                  return 2081;
9258                                                }
9259                                            }
9260                                          else
9261                                            {
9262                                              /* 33222222222211111111110000000000
9263                                                 10987654321098765432109876543210
9264                                                 111001x0x01xxxxx1x0xxxxxxxxxxxxx
9265                                                 st1h.  */
9266                                              return 1886;
9267                                            }
9268                                        }
9269                                      else
9270                                        {
9271                                          if (((word >> 23) & 0x1) == 0)
9272                                            {
9273                                              /* 33222222222211111111110000000000
9274                                                 10987654321098765432109876543210
9275                                                 x11001x0011xxxxx1x0xxxxxxxxxxxxx
9276                                                 bfdot.  */
9277                                              return 2419;
9278                                            }
9279                                          else
9280                                            {
9281                                              if (((word >> 31) & 0x1) == 0)
9282                                                {
9283                                                  if (((word >> 10) & 0x1) == 0)
9284                                                    {
9285                                                      /* 33222222222211111111110000000000
9286                                                         10987654321098765432109876543210
9287                                                         011001x0111xxxxx1x0xx0xxxxxxxxxx
9288                                                         bfmlalb.  */
9289                                                      return 2425;
9290                                                    }
9291                                                  else
9292                                                    {
9293                                                      /* 33222222222211111111110000000000
9294                                                         10987654321098765432109876543210
9295                                                         011001x0111xxxxx1x0xx1xxxxxxxxxx
9296                                                         bfmlalt.  */
9297                                                      return 2424;
9298                                                    }
9299                                                }
9300                                              else
9301                                                {
9302                                                  /* 33222222222211111111110000000000
9303                                                     10987654321098765432109876543210
9304                                                     111001x0111xxxxx1x0xxxxxxxxxxxxx
9305                                                     st1h.  */
9306                                                  return 1891;
9307                                                }
9308                                            }
9309                                        }
9310                                    }
9311                                }
9312                            }
9313                          else
9314                            {
9315                              if (((word >> 30) & 0x1) == 0)
9316                                {
9317                                  if (((word >> 31) & 0x1) == 0)
9318                                    {
9319                                      if (((word >> 4) & 0x1) == 0)
9320                                        {
9321                                          /* 33222222222211111111110000000000
9322                                             10987654321098765432109876543210
9323                                             001001x0xx1xxxxxxx1xxxxxxxx0xxxx
9324                                             cmplo.  */
9325                                          return 1335;
9326                                        }
9327                                      else
9328                                        {
9329                                          /* 33222222222211111111110000000000
9330                                             10987654321098765432109876543210
9331                                             001001x0xx1xxxxxxx1xxxxxxxx1xxxx
9332                                             cmpls.  */
9333                                          return 1337;
9334                                        }
9335                                    }
9336                                  else
9337                                    {
9338                                      if (((word >> 14) & 0x1) == 0)
9339                                        {
9340                                          if (((word >> 15) & 0x1) == 0)
9341                                            {
9342                                              if (((word >> 23) & 0x1) == 0)
9343                                                {
9344                                                  /* 33222222222211111111110000000000
9345                                                     10987654321098765432109876543210
9346                                                     101001x00x1xxxxx001xxxxxxxxxxxxx
9347                                                     ld1rob.  */
9348                                                  return 2403;
9349                                                }
9350                                              else
9351                                                {
9352                                                  /* 33222222222211111111110000000000
9353                                                     10987654321098765432109876543210
9354                                                     101001x01x1xxxxx001xxxxxxxxxxxxx
9355                                                     ld1roh.  */
9356                                                  return 2404;
9357                                                }
9358                                            }
9359                                          else
9360                                            {
9361                                              if (((word >> 20) & 0x1) == 0)
9362                                                {
9363                                                  if (((word >> 22) & 0x1) == 0)
9364                                                    {
9365                                                      if (((word >> 23) & 0x1) == 0)
9366                                                        {
9367                                                          /* 33222222222211111111110000000000
9368                                                             10987654321098765432109876543210
9369                                                             101001x00010xxxx101xxxxxxxxxxxxx
9370                                                             ld1b.  */
9371                                                          return 1509;
9372                                                        }
9373                                                      else
9374                                                        {
9375                                                          /* 33222222222211111111110000000000
9376                                                             10987654321098765432109876543210
9377                                                             101001x01010xxxx101xxxxxxxxxxxxx
9378                                                             ld1h.  */
9379                                                          return 1530;
9380                                                        }
9381                                                    }
9382                                                  else
9383                                                    {
9384                                                      if (((word >> 23) & 0x1) == 0)
9385                                                        {
9386                                                          /* 33222222222211111111110000000000
9387                                                             10987654321098765432109876543210
9388                                                             101001x00110xxxx101xxxxxxxxxxxxx
9389                                                             ld1b.  */
9390                                                          return 1511;
9391                                                        }
9392                                                      else
9393                                                        {
9394                                                          /* 33222222222211111111110000000000
9395                                                             10987654321098765432109876543210
9396                                                             101001x01110xxxx101xxxxxxxxxxxxx
9397                                                             ld1h.  */
9398                                                          return 1532;
9399                                                        }
9400                                                    }
9401                                                }
9402                                              else
9403                                                {
9404                                                  if (((word >> 22) & 0x1) == 0)
9405                                                    {
9406                                                      if (((word >> 23) & 0x1) == 0)
9407                                                        {
9408                                                          /* 33222222222211111111110000000000
9409                                                             10987654321098765432109876543210
9410                                                             101001x00011xxxx101xxxxxxxxxxxxx
9411                                                             ldnf1b.  */
9412                                                          return 1701;
9413                                                        }
9414                                                      else
9415                                                        {
9416                                                          /* 33222222222211111111110000000000
9417                                                             10987654321098765432109876543210
9418                                                             101001x01011xxxx101xxxxxxxxxxxxx
9419                                                             ldnf1h.  */
9420                                                          return 1705;
9421                                                        }
9422                                                    }
9423                                                  else
9424                                                    {
9425                                                      if (((word >> 23) & 0x1) == 0)
9426                                                        {
9427                                                          /* 33222222222211111111110000000000
9428                                                             10987654321098765432109876543210
9429                                                             101001x00111xxxx101xxxxxxxxxxxxx
9430                                                             ldnf1b.  */
9431                                                          return 1703;
9432                                                        }
9433                                                      else
9434                                                        {
9435                                                          /* 33222222222211111111110000000000
9436                                                             10987654321098765432109876543210
9437                                                             101001x01111xxxx101xxxxxxxxxxxxx
9438                                                             ldnf1h.  */
9439                                                          return 1707;
9440                                                        }
9441                                                    }
9442                                                }
9443                                            }
9444                                        }
9445                                      else
9446                                        {
9447                                          if (((word >> 15) & 0x1) == 0)
9448                                            {
9449                                              if (((word >> 22) & 0x1) == 0)
9450                                                {
9451                                                  if (((word >> 23) & 0x1) == 0)
9452                                                    {
9453                                                      /* 33222222222211111111110000000000
9454                                                         10987654321098765432109876543210
9455                                                         101001x0001xxxxx011xxxxxxxxxxxxx
9456                                                         ldff1b.  */
9457                                                      return 1627;
9458                                                    }
9459                                                  else
9460                                                    {
9461                                                      /* 33222222222211111111110000000000
9462                                                         10987654321098765432109876543210
9463                                                         101001x0101xxxxx011xxxxxxxxxxxxx
9464                                                         ldff1h.  */
9465                                                      return 1646;
9466                                                    }
9467                                                }
9468                                              else
9469                                                {
9470                                                  if (((word >> 23) & 0x1) == 0)
9471                                                    {
9472                                                      /* 33222222222211111111110000000000
9473                                                         10987654321098765432109876543210
9474                                                         101001x0011xxxxx011xxxxxxxxxxxxx
9475                                                         ldff1b.  */
9476                                                      return 1631;
9477                                                    }
9478                                                  else
9479                                                    {
9480                                                      /* 33222222222211111111110000000000
9481                                                         10987654321098765432109876543210
9482                                                         101001x0111xxxxx011xxxxxxxxxxxxx
9483                                                         ldff1h.  */
9484                                                      return 1650;
9485                                                    }
9486                                                }
9487                                            }
9488                                          else
9489                                            {
9490                                              if (((word >> 22) & 0x1) == 0)
9491                                                {
9492                                                  if (((word >> 23) & 0x1) == 0)
9493                                                    {
9494                                                      /* 33222222222211111111110000000000
9495                                                         10987654321098765432109876543210
9496                                                         101001x0001xxxxx111xxxxxxxxxxxxx
9497                                                         ld2b.  */
9498                                                      return 1601;
9499                                                    }
9500                                                  else
9501                                                    {
9502                                                      /* 33222222222211111111110000000000
9503                                                         10987654321098765432109876543210
9504                                                         101001x0101xxxxx111xxxxxxxxxxxxx
9505                                                         ld2h.  */
9506                                                      return 1605;
9507                                                    }
9508                                                }
9509                                              else
9510                                                {
9511                                                  if (((word >> 23) & 0x1) == 0)
9512                                                    {
9513                                                      /* 33222222222211111111110000000000
9514                                                         10987654321098765432109876543210
9515                                                         101001x0011xxxxx111xxxxxxxxxxxxx
9516                                                         ld4b.  */
9517                                                      return 1617;
9518                                                    }
9519                                                  else
9520                                                    {
9521                                                      /* 33222222222211111111110000000000
9522                                                         10987654321098765432109876543210
9523                                                         101001x0111xxxxx111xxxxxxxxxxxxx
9524                                                         ld4h.  */
9525                                                      return 1621;
9526                                                    }
9527                                                }
9528                                            }
9529                                        }
9530                                    }
9531                                }
9532                              else
9533                                {
9534                                  if (((word >> 14) & 0x1) == 0)
9535                                    {
9536                                      if (((word >> 15) & 0x1) == 0)
9537                                        {
9538                                          if (((word >> 23) & 0x1) == 0)
9539                                            {
9540                                              /* 33222222222211111111110000000000
9541                                                 10987654321098765432109876543210
9542                                                 x11001x00x1xxxxx001xxxxxxxxxxxxx
9543                                                 fmul.  */
9544                                              return 1450;
9545                                            }
9546                                          else
9547                                            {
9548                                              if (((word >> 22) & 0x1) == 0)
9549                                                {
9550                                                  /* 33222222222211111111110000000000
9551                                                     10987654321098765432109876543210
9552                                                     x11001x0101xxxxx001xxxxxxxxxxxxx
9553                                                     fmul.  */
9554                                                  return 1451;
9555                                                }
9556                                              else
9557                                                {
9558                                                  /* 33222222222211111111110000000000
9559                                                     10987654321098765432109876543210
9560                                                     x11001x0111xxxxx001xxxxxxxxxxxxx
9561                                                     fmul.  */
9562                                                  return 1452;
9563                                                }
9564                                            }
9565                                        }
9566                                      else
9567                                        {
9568                                          if (((word >> 22) & 0x1) == 0)
9569                                            {
9570                                              if (((word >> 31) & 0x1) == 0)
9571                                                {
9572                                                  if (((word >> 10) & 0x1) == 0)
9573                                                    {
9574                                                      /* 33222222222211111111110000000000
9575                                                         10987654321098765432109876543210
9576                                                         011001x0x01xxxxx101xx0xxxxxxxxxx
9577                                                         fmlslb.  */
9578                                                      return 2083;
9579                                                    }
9580                                                  else
9581                                                    {
9582                                                      /* 33222222222211111111110000000000
9583                                                         10987654321098765432109876543210
9584                                                         011001x0x01xxxxx101xx1xxxxxxxxxx
9585                                                         fmlslt.  */
9586                                                      return 2085;
9587                                                    }
9588                                                }
9589                                              else
9590                                                {
9591                                                  /* 33222222222211111111110000000000
9592                                                     10987654321098765432109876543210
9593                                                     111001x0x01xxxxx101xxxxxxxxxxxxx
9594                                                     st1h.  */
9595                                                  return 1887;
9596                                                }
9597                                            }
9598                                          else
9599                                            {
9600                                              if (((word >> 23) & 0x1) == 0)
9601                                                {
9602                                                  /* 33222222222211111111110000000000
9603                                                     10987654321098765432109876543210
9604                                                     x11001x0011xxxxx101xxxxxxxxxxxxx
9605                                                     st1b.  */
9606                                                  return 1874;
9607                                                }
9608                                              else
9609                                                {
9610                                                  /* 33222222222211111111110000000000
9611                                                     10987654321098765432109876543210
9612                                                     x11001x0111xxxxx101xxxxxxxxxxxxx
9613                                                     st1h.  */
9614                                                  return 1895;
9615                                                }
9616                                            }
9617                                        }
9618                                    }
9619                                  else
9620                                    {
9621                                      if (((word >> 15) & 0x1) == 0)
9622                                        {
9623                                          if (((word >> 22) & 0x1) == 0)
9624                                            {
9625                                              if (((word >> 23) & 0x1) == 0)
9626                                                {
9627                                                  /* 33222222222211111111110000000000
9628                                                     10987654321098765432109876543210
9629                                                     x11001x0001xxxxx011xxxxxxxxxxxxx
9630                                                     st2b.  */
9631                                                  return 1909;
9632                                                }
9633                                              else
9634                                                {
9635                                                  if (((word >> 31) & 0x1) == 0)
9636                                                    {
9637                                                      if (((word >> 10) & 0x1) == 0)
9638                                                        {
9639                                                          /* 33222222222211111111110000000000
9640                                                             10987654321098765432109876543210
9641                                                             011001x0101xxxxx011xx0xxxxxxxxxx
9642                                                             fmlslb.  */
9643                                                          return 2082;
9644                                                        }
9645                                                      else
9646                                                        {
9647                                                          /* 33222222222211111111110000000000
9648                                                             10987654321098765432109876543210
9649                                                             011001x0101xxxxx011xx1xxxxxxxxxx
9650                                                             fmlslt.  */
9651                                                          return 2084;
9652                                                        }
9653                                                    }
9654                                                  else
9655                                                    {
9656                                                      /* 33222222222211111111110000000000
9657                                                         10987654321098765432109876543210
9658                                                         111001x0101xxxxx011xxxxxxxxxxxxx
9659                                                         st2h.  */
9660                                                      return 1913;
9661                                                    }
9662                                                }
9663                                            }
9664                                          else
9665                                            {
9666                                              if (((word >> 23) & 0x1) == 0)
9667                                                {
9668                                                  /* 33222222222211111111110000000000
9669                                                     10987654321098765432109876543210
9670                                                     x11001x0011xxxxx011xxxxxxxxxxxxx
9671                                                     st4b.  */
9672                                                  return 1925;
9673                                                }
9674                                              else
9675                                                {
9676                                                  /* 33222222222211111111110000000000
9677                                                     10987654321098765432109876543210
9678                                                     x11001x0111xxxxx011xxxxxxxxxxxxx
9679                                                     st4h.  */
9680                                                  return 1929;
9681                                                }
9682                                            }
9683                                        }
9684                                      else
9685                                        {
9686                                          if (((word >> 22) & 0x1) == 0)
9687                                            {
9688                                              if (((word >> 23) & 0x1) == 0)
9689                                                {
9690                                                  if (((word >> 20) & 0x1) == 0)
9691                                                    {
9692                                                      /* 33222222222211111111110000000000
9693                                                         10987654321098765432109876543210
9694                                                         x11001x00010xxxx111xxxxxxxxxxxxx
9695                                                         st1b.  */
9696                                                      return 1871;
9697                                                    }
9698                                                  else
9699                                                    {
9700                                                      /* 33222222222211111111110000000000
9701                                                         10987654321098765432109876543210
9702                                                         x11001x00011xxxx111xxxxxxxxxxxxx
9703                                                         st2b.  */
9704                                                      return 1910;
9705                                                    }
9706                                                }
9707                                              else
9708                                                {
9709                                                  if (((word >> 31) & 0x1) == 0)
9710                                                    {
9711                                                      /* 33222222222211111111110000000000
9712                                                         10987654321098765432109876543210
9713                                                         011001x0101xxxxx111xxxxxxxxxxxxx
9714                                                         fmmla.  */
9715                                                      return 2397;
9716                                                    }
9717                                                  else
9718                                                    {
9719                                                      if (((word >> 20) & 0x1) == 0)
9720                                                        {
9721                                                          /* 33222222222211111111110000000000
9722                                                             10987654321098765432109876543210
9723                                                             111001x01010xxxx111xxxxxxxxxxxxx
9724                                                             st1h.  */
9725                                                          return 1892;
9726                                                        }
9727                                                      else
9728                                                        {
9729                                                          /* 33222222222211111111110000000000
9730                                                             10987654321098765432109876543210
9731                                                             111001x01011xxxx111xxxxxxxxxxxxx
9732                                                             st2h.  */
9733                                                          return 1914;
9734                                                        }
9735                                                    }
9736                                                }
9737                                            }
9738                                          else
9739                                            {
9740                                              if (((word >> 23) & 0x1) == 0)
9741                                                {
9742                                                  if (((word >> 31) & 0x1) == 0)
9743                                                    {
9744                                                      /* 33222222222211111111110000000000
9745                                                         10987654321098765432109876543210
9746                                                         011001x0011xxxxx111xxxxxxxxxxxxx
9747                                                         bfmmla.  */
9748                                                      return 2421;
9749                                                    }
9750                                                  else
9751                                                    {
9752                                                      if (((word >> 20) & 0x1) == 0)
9753                                                        {
9754                                                          /* 33222222222211111111110000000000
9755                                                             10987654321098765432109876543210
9756                                                             111001x00110xxxx111xxxxxxxxxxxxx
9757                                                             st1b.  */
9758                                                          return 1875;
9759                                                        }
9760                                                      else
9761                                                        {
9762                                                          /* 33222222222211111111110000000000
9763                                                             10987654321098765432109876543210
9764                                                             111001x00111xxxx111xxxxxxxxxxxxx
9765                                                             st4b.  */
9766                                                          return 1926;
9767                                                        }
9768                                                    }
9769                                                }
9770                                              else
9771                                                {
9772                                                  if (((word >> 31) & 0x1) == 0)
9773                                                    {
9774                                                      /* 33222222222211111111110000000000
9775                                                         10987654321098765432109876543210
9776                                                         011001x0111xxxxx111xxxxxxxxxxxxx
9777                                                         fmmla.  */
9778                                                      return 2398;
9779                                                    }
9780                                                  else
9781                                                    {
9782                                                      if (((word >> 20) & 0x1) == 0)
9783                                                        {
9784                                                          /* 33222222222211111111110000000000
9785                                                             10987654321098765432109876543210
9786                                                             111001x01110xxxx111xxxxxxxxxxxxx
9787                                                             st1h.  */
9788                                                          return 1896;
9789                                                        }
9790                                                      else
9791                                                        {
9792                                                          /* 33222222222211111111110000000000
9793                                                             10987654321098765432109876543210
9794                                                             111001x01111xxxx111xxxxxxxxxxxxx
9795                                                             st4h.  */
9796                                                          return 1930;
9797                                                        }
9798                                                    }
9799                                                }
9800                                            }
9801                                        }
9802                                    }
9803                                }
9804                            }
9805                        }
9806                    }
9807                }
9808              else
9809                {
9810                  if (((word >> 29) & 0x1) == 0)
9811                    {
9812                      if (((word >> 30) & 0x1) == 0)
9813                        {
9814                          if (((word >> 31) & 0x1) == 0)
9815                            {
9816                              if (((word >> 21) & 0x1) == 0)
9817                                {
9818                                  if (((word >> 20) & 0x1) == 0)
9819                                    {
9820                                      if (((word >> 22) & 0x1) == 0)
9821                                        {
9822                                          if (((word >> 23) & 0x1) == 0)
9823                                            {
9824                                              /* 33222222222211111111110000000000
9825                                                 10987654321098765432109876543210
9826                                                 000001x10000xxxxxxxxxxxxxxxxxxxx
9827                                                 orr.  */
9828                                              return 1755;
9829                                            }
9830                                          else
9831                                            {
9832                                              /* 33222222222211111111110000000000
9833                                                 10987654321098765432109876543210
9834                                                 000001x11000xxxxxxxxxxxxxxxxxxxx
9835                                                 and.  */
9836                                              return 1283;
9837                                            }
9838                                        }
9839                                      else
9840                                        {
9841                                          if (((word >> 23) & 0x1) == 0)
9842                                            {
9843                                              /* 33222222222211111111110000000000
9844                                                 10987654321098765432109876543210
9845                                                 000001x10100xxxxxxxxxxxxxxxxxxxx
9846                                                 eor.  */
9847                                              return 1370;
9848                                            }
9849                                          else
9850                                            {
9851                                              /* 33222222222211111111110000000000
9852                                                 10987654321098765432109876543210
9853                                                 000001x11100xxxxxxxxxxxxxxxxxxxx
9854                                                 dupm.  */
9855                                              return 1368;
9856                                            }
9857                                        }
9858                                    }
9859                                  else
9860                                    {
9861                                      if (((word >> 15) & 0x1) == 0)
9862                                        {
9863                                          /* 33222222222211111111110000000000
9864                                             10987654321098765432109876543210
9865                                             000001x1xx01xxxx0xxxxxxxxxxxxxxx
9866                                             cpy.  */
9867                                          return 1353;
9868                                        }
9869                                      else
9870                                        {
9871                                          /* 33222222222211111111110000000000
9872                                             10987654321098765432109876543210
9873                                             000001x1xx01xxxx1xxxxxxxxxxxxxxx
9874                                             fcpy.  */
9875                                          return 1400;
9876                                        }
9877                                    }
9878                                }
9879                              else
9880                                {
9881                                  if (((word >> 14) & 0x1) == 0)
9882                                    {
9883                                      if (((word >> 13) & 0x1) == 0)
9884                                        {
9885                                          if (((word >> 15) & 0x1) == 0)
9886                                            {
9887                                              if (((word >> 22) & 0x1) == 0)
9888                                                {
9889                                                  if (((word >> 23) & 0x1) == 0)
9890                                                    {
9891                                                      /* 33222222222211111111110000000000
9892                                                         10987654321098765432109876543210
9893                                                         000001x1001xxxxx000xxxxxxxxxxxxx
9894                                                         ext.  */
9895                                                      return 1375;
9896                                                    }
9897                                                  else
9898                                                    {
9899                                                      if (((word >> 10) & 0x1) == 0)
9900                                                        {
9901                                                          if (((word >> 11) & 0x1) == 0)
9902                                                            {
9903                                                              /* 33222222222211111111110000000000
9904                                                                 10987654321098765432109876543210
9905                                                                 000001x1101xxxxx000x00xxxxxxxxxx
9906                                                                 zip1.  */
9907                                                              return 2407;
9908                                                            }
9909                                                          else
9910                                                            {
9911                                                              if (((word >> 12) & 0x1) == 0)
9912                                                                {
9913                                                                  /* 33222222222211111111110000000000
9914                                                                     10987654321098765432109876543210
9915                                                                     000001x1101xxxxx000010xxxxxxxxxx
9916                                                                     uzp1.  */
9917                                                                  return 2409;
9918                                                                }
9919                                                              else
9920                                                                {
9921                                                                  /* 33222222222211111111110000000000
9922                                                                     10987654321098765432109876543210
9923                                                                     000001x1101xxxxx000110xxxxxxxxxx
9924                                                                     trn1.  */
9925                                                                  return 2411;
9926                                                                }
9927                                                            }
9928                                                        }
9929                                                      else
9930                                                        {
9931                                                          if (((word >> 11) & 0x1) == 0)
9932                                                            {
9933                                                              /* 33222222222211111111110000000000
9934                                                                 10987654321098765432109876543210
9935                                                                 000001x1101xxxxx000x01xxxxxxxxxx
9936                                                                 zip2.  */
9937                                                              return 2408;
9938                                                            }
9939                                                          else
9940                                                            {
9941                                                              if (((word >> 12) & 0x1) == 0)
9942                                                                {
9943                                                                  /* 33222222222211111111110000000000
9944                                                                     10987654321098765432109876543210
9945                                                                     000001x1101xxxxx000011xxxxxxxxxx
9946                                                                     uzp2.  */
9947                                                                  return 2410;
9948                                                                }
9949                                                              else
9950                                                                {
9951                                                                  /* 33222222222211111111110000000000
9952                                                                     10987654321098765432109876543210
9953                                                                     000001x1101xxxxx000111xxxxxxxxxx
9954                                                                     trn2.  */
9955                                                                  return 2412;
9956                                                                }
9957                                                            }
9958                                                        }
9959                                                    }
9960                                                }
9961                                              else
9962                                                {
9963                                                  /* 33222222222211111111110000000000
9964                                                     10987654321098765432109876543210
9965                                                     000001x1x11xxxxx000xxxxxxxxxxxxx
9966                                                     ext.  */
9967                                                  return 2065;
9968                                                }
9969                                            }
9970                                          else
9971                                            {
9972                                              if (((word >> 16) & 0x1) == 0)
9973                                                {
9974                                                  if (((word >> 17) & 0x1) == 0)
9975                                                    {
9976                                                      if (((word >> 18) & 0x1) == 0)
9977                                                        {
9978                                                          if (((word >> 19) & 0x1) == 0)
9979                                                            {
9980                                                              /* 33222222222211111111110000000000
9981                                                                 10987654321098765432109876543210
9982                                                                 000001x1xx1x0000100xxxxxxxxxxxxx
9983                                                                 cpy.  */
9984                                                              return 1351;
9985                                                            }
9986                                                          else
9987                                                            {
9988                                                              /* 33222222222211111111110000000000
9989                                                                 10987654321098765432109876543210
9990                                                                 000001x1xx1x1000100xxxxxxxxxxxxx
9991                                                                 clasta.  */
9992                                                              return 1309;
9993                                                            }
9994                                                        }
9995                                                      else
9996                                                        {
9997                                                          if (((word >> 19) & 0x1) == 0)
9998                                                            {
9999                                                              /* 33222222222211111111110000000000
10000                                                                 10987654321098765432109876543210
10001                                                                 000001x1xx1x0100100xxxxxxxxxxxxx
10002                                                                 revb.  */
10003                                                              return 1803;
10004                                                            }
10005                                                          else
10006                                                            {
10007                                                              /* 33222222222211111111110000000000
10008                                                                 10987654321098765432109876543210
10009                                                                 000001x1xx1x1100100xxxxxxxxxxxxx
10010                                                                 splice.  */
10011                                                              return 1830;
10012                                                            }
10013                                                        }
10014                                                    }
10015                                                  else
10016                                                    {
10017                                                      if (((word >> 18) & 0x1) == 0)
10018                                                        {
10019                                                          if (((word >> 19) & 0x1) == 0)
10020                                                            {
10021                                                              /* 33222222222211111111110000000000
10022                                                                 10987654321098765432109876543210
10023                                                                 000001x1xx1x0010100xxxxxxxxxxxxx
10024                                                                 lasta.  */
10025                                                              return 1497;
10026                                                            }
10027                                                          else
10028                                                            {
10029                                                              /* 33222222222211111111110000000000
10030                                                                 10987654321098765432109876543210
10031                                                                 000001x1xx1x1010100xxxxxxxxxxxxx
10032                                                                 clasta.  */
10033                                                              return 1310;
10034                                                            }
10035                                                        }
10036                                                      else
10037                                                        {
10038                                                          /* 33222222222211111111110000000000
10039                                                             10987654321098765432109876543210
10040                                                             000001x1xx1xx110100xxxxxxxxxxxxx
10041                                                             revw.  */
10042                                                          return 1805;
10043                                                        }
10044                                                    }
10045                                                }
10046                                              else
10047                                                {
10048                                                  if (((word >> 17) & 0x1) == 0)
10049                                                    {
10050                                                      if (((word >> 18) & 0x1) == 0)
10051                                                        {
10052                                                          if (((word >> 19) & 0x1) == 0)
10053                                                            {
10054                                                              /* 33222222222211111111110000000000
10055                                                                 10987654321098765432109876543210
10056                                                                 000001x1xx1x0001100xxxxxxxxxxxxx
10057                                                                 compact.  */
10058                                                              return 1350;
10059                                                            }
10060                                                          else
10061                                                            {
10062                                                              /* 33222222222211111111110000000000
10063                                                                 10987654321098765432109876543210
10064                                                                 000001x1xx1x1001100xxxxxxxxxxxxx
10065                                                                 clastb.  */
10066                                                              return 1312;
10067                                                            }
10068                                                        }
10069                                                      else
10070                                                        {
10071                                                          if (((word >> 19) & 0x1) == 0)
10072                                                            {
10073                                                              /* 33222222222211111111110000000000
10074                                                                 10987654321098765432109876543210
10075                                                                 000001x1xx1x0101100xxxxxxxxxxxxx
10076                                                                 revh.  */
10077                                                              return 1804;
10078                                                            }
10079                                                          else
10080                                                            {
10081                                                              /* 33222222222211111111110000000000
10082                                                                 10987654321098765432109876543210
10083                                                                 000001x1xx1x1101100xxxxxxxxxxxxx
10084                                                                 splice.  */
10085                                                              return 2160;
10086                                                            }
10087                                                        }
10088                                                    }
10089                                                  else
10090                                                    {
10091                                                      if (((word >> 18) & 0x1) == 0)
10092                                                        {
10093                                                          if (((word >> 19) & 0x1) == 0)
10094                                                            {
10095                                                              /* 33222222222211111111110000000000
10096                                                                 10987654321098765432109876543210
10097                                                                 000001x1xx1x0011100xxxxxxxxxxxxx
10098                                                                 lastb.  */
10099                                                              return 1499;
10100                                                            }
10101                                                          else
10102                                                            {
10103                                                              /* 33222222222211111111110000000000
10104                                                                 10987654321098765432109876543210
10105                                                                 000001x1xx1x1011100xxxxxxxxxxxxx
10106                                                                 clastb.  */
10107                                                              return 1313;
10108                                                            }
10109                                                        }
10110                                                      else
10111                                                        {
10112                                                          /* 33222222222211111111110000000000
10113                                                             10987654321098765432109876543210
10114                                                             000001x1xx1xx111100xxxxxxxxxxxxx
10115                                                             rbit.  */
10116                                                          return 1796;
10117                                                        }
10118                                                    }
10119                                                }
10120                                            }
10121                                        }
10122                                      else
10123                                        {
10124                                          if (((word >> 15) & 0x1) == 0)
10125                                            {
10126                                              if (((word >> 10) & 0x1) == 0)
10127                                                {
10128                                                  if (((word >> 11) & 0x1) == 0)
10129                                                    {
10130                                                      if (((word >> 12) & 0x1) == 0)
10131                                                        {
10132                                                          /* 33222222222211111111110000000000
10133                                                             10987654321098765432109876543210
10134                                                             000001x1xx1xxxxx001000xxxxxxxxxx
10135                                                             dup.  */
10136                                                          return 1366;
10137                                                        }
10138                                                      else
10139                                                        {
10140                                                          /* 33222222222211111111110000000000
10141                                                             10987654321098765432109876543210
10142                                                             000001x1xx1xxxxx001100xxxxxxxxxx
10143                                                             tbl.  */
10144                                                          return 1953;
10145                                                        }
10146                                                    }
10147                                                  else
10148                                                    {
10149                                                      if (((word >> 12) & 0x1) == 0)
10150                                                        {
10151                                                          /* 33222222222211111111110000000000
10152                                                             10987654321098765432109876543210
10153                                                             000001x1xx1xxxxx001010xxxxxxxxxx
10154                                                             tbl.  */
10155                                                          return 2249;
10156                                                        }
10157                                                      else
10158                                                        {
10159                                                          if (((word >> 16) & 0x1) == 0)
10160                                                            {
10161                                                              if (((word >> 17) & 0x1) == 0)
10162                                                                {
10163                                                                  if (((word >> 18) & 0x1) == 0)
10164                                                                    {
10165                                                                      if (((word >> 19) & 0x1) == 0)
10166                                                                        {
10167                                                                          if (((word >> 20) & 0x1) == 0)
10168                                                                            {
10169                                                                              /* 33222222222211111111110000000000
10170                                                                                 10987654321098765432109876543210
10171                                                                                 000001x1xx100000001110xxxxxxxxxx
10172                                                                                 dup.  */
10173                                                                              return 1365;
10174                                                                            }
10175                                                                          else
10176                                                                            {
10177                                                                              /* 33222222222211111111110000000000
10178                                                                                 10987654321098765432109876543210
10179                                                                                 000001x1xx110000001110xxxxxxxxxx
10180                                                                                 sunpklo.  */
10181                                                                              return 1949;
10182                                                                            }
10183                                                                        }
10184                                                                      else
10185                                                                        {
10186                                                                          /* 33222222222211111111110000000000
10187                                                                             10987654321098765432109876543210
10188                                                                             000001x1xx1x1000001110xxxxxxxxxx
10189                                                                             rev.  */
10190                                                                          return 1802;
10191                                                                        }
10192                                                                    }
10193                                                                  else
10194                                                                    {
10195                                                                      if (((word >> 20) & 0x1) == 0)
10196                                                                        {
10197                                                                          /* 33222222222211111111110000000000
10198                                                                             10987654321098765432109876543210
10199                                                                             000001x1xx10x100001110xxxxxxxxxx
10200                                                                             insr.  */
10201                                                                          return 1494;
10202                                                                        }
10203                                                                      else
10204                                                                        {
10205                                                                          /* 33222222222211111111110000000000
10206                                                                             10987654321098765432109876543210
10207                                                                             000001x1xx11x100001110xxxxxxxxxx
10208                                                                             insr.  */
10209                                                                          return 1495;
10210                                                                        }
10211                                                                    }
10212                                                                }
10213                                                              else
10214                                                                {
10215                                                                  /* 33222222222211111111110000000000
10216                                                                     10987654321098765432109876543210
10217                                                                     000001x1xx1xxx10001110xxxxxxxxxx
10218                                                                     uunpklo.  */
10219                                                                  return 2012;
10220                                                                }
10221                                                            }
10222                                                          else
10223                                                            {
10224                                                              if (((word >> 17) & 0x1) == 0)
10225                                                                {
10226                                                                  /* 33222222222211111111110000000000
10227                                                                     10987654321098765432109876543210
10228                                                                     000001x1xx1xxx01001110xxxxxxxxxx
10229                                                                     sunpkhi.  */
10230                                                                  return 1948;
10231                                                                }
10232                                                              else
10233                                                                {
10234                                                                  /* 33222222222211111111110000000000
10235                                                                     10987654321098765432109876543210
10236                                                                     000001x1xx1xxx11001110xxxxxxxxxx
10237                                                                     uunpkhi.  */
10238                                                                  return 2011;
10239                                                                }
10240                                                            }
10241                                                        }
10242                                                    }
10243                                                }
10244                                              else
10245                                                {
10246                                                  /* 33222222222211111111110000000000
10247                                                     10987654321098765432109876543210
10248                                                     000001x1xx1xxxxx001xx1xxxxxxxxxx
10249                                                     tbx.  */
10250                                                  return 2250;
10251                                                }
10252                                            }
10253                                          else
10254                                            {
10255                                              if (((word >> 16) & 0x1) == 0)
10256                                                {
10257                                                  if (((word >> 19) & 0x1) == 0)
10258                                                    {
10259                                                      if (((word >> 20) & 0x1) == 0)
10260                                                        {
10261                                                          /* 33222222222211111111110000000000
10262                                                             10987654321098765432109876543210
10263                                                             000001x1xx100xx0101xxxxxxxxxxxxx
10264                                                             lasta.  */
10265                                                          return 1496;
10266                                                        }
10267                                                      else
10268                                                        {
10269                                                          /* 33222222222211111111110000000000
10270                                                             10987654321098765432109876543210
10271                                                             000001x1xx110xx0101xxxxxxxxxxxxx
10272                                                             clasta.  */
10273                                                          return 1311;
10274                                                        }
10275                                                    }
10276                                                  else
10277                                                    {
10278                                                      /* 33222222222211111111110000000000
10279                                                         10987654321098765432109876543210
10280                                                         000001x1xx1x1xx0101xxxxxxxxxxxxx
10281                                                         cpy.  */
10282                                                      return 1352;
10283                                                    }
10284                                                }
10285                                              else
10286                                                {
10287                                                  if (((word >> 20) & 0x1) == 0)
10288                                                    {
10289                                                      /* 33222222222211111111110000000000
10290                                                         10987654321098765432109876543210
10291                                                         000001x1xx10xxx1101xxxxxxxxxxxxx
10292                                                         lastb.  */
10293                                                      return 1498;
10294                                                    }
10295                                                  else
10296                                                    {
10297                                                      /* 33222222222211111111110000000000
10298                                                         10987654321098765432109876543210
10299                                                         000001x1xx11xxx1101xxxxxxxxxxxxx
10300                                                         clastb.  */
10301                                                      return 1314;
10302                                                    }
10303                                                }
10304                                            }
10305                                        }
10306                                    }
10307                                  else
10308                                    {
10309                                      if (((word >> 15) & 0x1) == 0)
10310                                        {
10311                                          if (((word >> 10) & 0x1) == 0)
10312                                            {
10313                                              if (((word >> 11) & 0x1) == 0)
10314                                                {
10315                                                  if (((word >> 12) & 0x1) == 0)
10316                                                    {
10317                                                      if (((word >> 13) & 0x1) == 0)
10318                                                        {
10319                                                          if (((word >> 20) & 0x1) == 0)
10320                                                            {
10321                                                              /* 33222222222211111111110000000000
10322                                                                 10987654321098765432109876543210
10323                                                                 000001x1xx10xxxx010000xxxxxxxxxx
10324                                                                 zip1.  */
10325                                                              return 2029;
10326                                                            }
10327                                                          else
10328                                                            {
10329                                                              if (((word >> 16) & 0x1) == 0)
10330                                                                {
10331                                                                  if (((word >> 18) & 0x1) == 0)
10332                                                                    {
10333                                                                      /* 33222222222211111111110000000000
10334                                                                         10987654321098765432109876543210
10335                                                                         000001x1xx11x0x0010000xxxxxxxxxx
10336                                                                         punpklo.  */
10337                                                                      return 1795;
10338                                                                    }
10339                                                                  else
10340                                                                    {
10341                                                                      /* 33222222222211111111110000000000
10342                                                                         10987654321098765432109876543210
10343                                                                         000001x1xx11x1x0010000xxxxxxxxxx
10344                                                                         rev.  */
10345                                                                      return 1801;
10346                                                                    }
10347                                                                }
10348                                                              else
10349                                                                {
10350                                                                  /* 33222222222211111111110000000000
10351                                                                     10987654321098765432109876543210
10352                                                                     000001x1xx11xxx1010000xxxxxxxxxx
10353                                                                     punpkhi.  */
10354                                                                  return 1794;
10355                                                                }
10356                                                            }
10357                                                        }
10358                                                      else
10359                                                        {
10360                                                          /* 33222222222211111111110000000000
10361                                                             10987654321098765432109876543210
10362                                                             000001x1xx1xxxxx011000xxxxxxxxxx
10363                                                             zip1.  */
10364                                                          return 2030;
10365                                                        }
10366                                                    }
10367                                                  else
10368                                                    {
10369                                                      if (((word >> 13) & 0x1) == 0)
10370                                                        {
10371                                                          /* 33222222222211111111110000000000
10372                                                             10987654321098765432109876543210
10373                                                             000001x1xx1xxxxx010100xxxxxxxxxx
10374                                                             trn1.  */
10375                                                          return 1954;
10376                                                        }
10377                                                      else
10378                                                        {
10379                                                          /* 33222222222211111111110000000000
10380                                                             10987654321098765432109876543210
10381                                                             000001x1xx1xxxxx011100xxxxxxxxxx
10382                                                             trn1.  */
10383                                                          return 1955;
10384                                                        }
10385                                                    }
10386                                                }
10387                                              else
10388                                                {
10389                                                  if (((word >> 13) & 0x1) == 0)
10390                                                    {
10391                                                      /* 33222222222211111111110000000000
10392                                                         10987654321098765432109876543210
10393                                                         000001x1xx1xxxxx010x10xxxxxxxxxx
10394                                                         uzp1.  */
10395                                                      return 2016;
10396                                                    }
10397                                                  else
10398                                                    {
10399                                                      /* 33222222222211111111110000000000
10400                                                         10987654321098765432109876543210
10401                                                         000001x1xx1xxxxx011x10xxxxxxxxxx
10402                                                         uzp1.  */
10403                                                      return 2017;
10404                                                    }
10405                                                }
10406                                            }
10407                                          else
10408                                            {
10409                                              if (((word >> 11) & 0x1) == 0)
10410                                                {
10411                                                  if (((word >> 12) & 0x1) == 0)
10412                                                    {
10413                                                      if (((word >> 13) & 0x1) == 0)
10414                                                        {
10415                                                          /* 33222222222211111111110000000000
10416                                                             10987654321098765432109876543210
10417                                                             000001x1xx1xxxxx010001xxxxxxxxxx
10418                                                             zip2.  */
10419                                                          return 2031;
10420                                                        }
10421                                                      else
10422                                                        {
10423                                                          /* 33222222222211111111110000000000
10424                                                             10987654321098765432109876543210
10425                                                             000001x1xx1xxxxx011001xxxxxxxxxx
10426                                                             zip2.  */
10427                                                          return 2032;
10428                                                        }
10429                                                    }
10430                                                  else
10431                                                    {
10432                                                      if (((word >> 13) & 0x1) == 0)
10433                                                        {
10434                                                          /* 33222222222211111111110000000000
10435                                                             10987654321098765432109876543210
10436                                                             000001x1xx1xxxxx010101xxxxxxxxxx
10437                                                             trn2.  */
10438                                                          return 1956;
10439                                                        }
10440                                                      else
10441                                                        {
10442                                                          /* 33222222222211111111110000000000
10443                                                             10987654321098765432109876543210
10444                                                             000001x1xx1xxxxx011101xxxxxxxxxx
10445                                                             trn2.  */
10446                                                          return 1957;
10447                                                        }
10448                                                    }
10449                                                }
10450                                              else
10451                                                {
10452                                                  if (((word >> 13) & 0x1) == 0)
10453                                                    {
10454                                                      /* 33222222222211111111110000000000
10455                                                         10987654321098765432109876543210
10456                                                         000001x1xx1xxxxx010x11xxxxxxxxxx
10457                                                         uzp2.  */
10458                                                      return 2018;
10459                                                    }
10460                                                  else
10461                                                    {
10462                                                      /* 33222222222211111111110000000000
10463                                                         10987654321098765432109876543210
10464                                                         000001x1xx1xxxxx011x11xxxxxxxxxx
10465                                                         uzp2.  */
10466                                                      return 2019;
10467                                                    }
10468                                                }
10469                                            }
10470                                        }
10471                                      else
10472                                        {
10473                                          /* 33222222222211111111110000000000
10474                                             10987654321098765432109876543210
10475                                             000001x1xx1xxxxx11xxxxxxxxxxxxxx
10476                                             sel.  */
10477                                          return 1820;
10478                                        }
10479                                    }
10480                                }
10481                            }
10482                          else
10483                            {
10484                              if (((word >> 13) & 0x1) == 0)
10485                                {
10486                                  if (((word >> 14) & 0x1) == 0)
10487                                    {
10488                                      if (((word >> 15) & 0x1) == 0)
10489                                        {
10490                                          if (((word >> 22) & 0x1) == 0)
10491                                            {
10492                                              /* 33222222222211111111110000000000
10493                                                 10987654321098765432109876543210
10494                                                 100001x1x0xxxxxx000xxxxxxxxxxxxx
10495                                                 ldr.  */
10496                                              return 1724;
10497                                            }
10498                                          else
10499                                            {
10500                                              /* 33222222222211111111110000000000
10501                                                 10987654321098765432109876543210
10502                                                 100001x1x1xxxxxx000xxxxxxxxxxxxx
10503                                                 prfb.  */
10504                                              return 1768;
10505                                            }
10506                                        }
10507                                      else
10508                                        {
10509                                          if (((word >> 23) & 0x1) == 0)
10510                                            {
10511                                              /* 33222222222211111111110000000000
10512                                                 10987654321098765432109876543210
10513                                                 100001x10xxxxxxx100xxxxxxxxxxxxx
10514                                                 ld1rsh.  */
10515                                              return 1553;
10516                                            }
10517                                          else
10518                                            {
10519                                              /* 33222222222211111111110000000000
10520                                                 10987654321098765432109876543210
10521                                                 100001x11xxxxxxx100xxxxxxxxxxxxx
10522                                                 ld1rsb.  */
10523                                              return 1550;
10524                                            }
10525                                        }
10526                                    }
10527                                  else
10528                                    {
10529                                      if (((word >> 15) & 0x1) == 0)
10530                                        {
10531                                          if (((word >> 23) & 0x1) == 0)
10532                                            {
10533                                              if (((word >> 21) & 0x1) == 0)
10534                                                {
10535                                                  /* 33222222222211111111110000000000
10536                                                     10987654321098765432109876543210
10537                                                     100001x10x0xxxxx010xxxxxxxxxxxxx
10538                                                     ld1w.  */
10539                                                  return 1588;
10540                                                }
10541                                              else
10542                                                {
10543                                                  /* 33222222222211111111110000000000
10544                                                     10987654321098765432109876543210
10545                                                     100001x10x1xxxxx010xxxxxxxxxxxxx
10546                                                     ld1w.  */
10547                                                  return 1589;
10548                                                }
10549                                            }
10550                                          else
10551                                            {
10552                                              if (((word >> 22) & 0x1) == 0)
10553                                                {
10554                                                  /* 33222222222211111111110000000000
10555                                                     10987654321098765432109876543210
10556                                                     100001x110xxxxxx010xxxxxxxxxxxxx
10557                                                     ldr.  */
10558                                                  return 1725;
10559                                                }
10560                                              else
10561                                                {
10562                                                  /* 33222222222211111111110000000000
10563                                                     10987654321098765432109876543210
10564                                                     100001x111xxxxxx010xxxxxxxxxxxxx
10565                                                     prfw.  */
10566                                                  return 1789;
10567                                                }
10568                                            }
10569                                        }
10570                                      else
10571                                        {
10572                                          if (((word >> 22) & 0x1) == 0)
10573                                            {
10574                                              if (((word >> 21) & 0x1) == 0)
10575                                                {
10576                                                  if (((word >> 23) & 0x1) == 0)
10577                                                    {
10578                                                      /* 33222222222211111111110000000000
10579                                                         10987654321098765432109876543210
10580                                                         100001x1000xxxxx110xxxxxxxxxxxxx
10581                                                         prfw.  */
10582                                                      return 1785;
10583                                                    }
10584                                                  else
10585                                                    {
10586                                                      /* 33222222222211111111110000000000
10587                                                         10987654321098765432109876543210
10588                                                         100001x1100xxxxx110xxxxxxxxxxxxx
10589                                                         prfd.  */
10590                                                      return 1771;
10591                                                    }
10592                                                }
10593                                              else
10594                                                {
10595                                                  /* 33222222222211111111110000000000
10596                                                     10987654321098765432109876543210
10597                                                     100001x1x01xxxxx110xxxxxxxxxxxxx
10598                                                     ld1w.  */
10599                                                  return 1596;
10600                                                }
10601                                            }
10602                                          else
10603                                            {
10604                                              if (((word >> 23) & 0x1) == 0)
10605                                                {
10606                                                  /* 33222222222211111111110000000000
10607                                                     10987654321098765432109876543210
10608                                                     100001x101xxxxxx110xxxxxxxxxxxxx
10609                                                     ld1rw.  */
10610                                                  return 1556;
10611                                                }
10612                                              else
10613                                                {
10614                                                  /* 33222222222211111111110000000000
10615                                                     10987654321098765432109876543210
10616                                                     100001x111xxxxxx110xxxxxxxxxxxxx
10617                                                     ld1rsb.  */
10618                                                  return 1552;
10619                                                }
10620                                            }
10621                                        }
10622                                    }
10623                                }
10624                              else
10625                                {
10626                                  if (((word >> 14) & 0x1) == 0)
10627                                    {
10628                                      if (((word >> 15) & 0x1) == 0)
10629                                        {
10630                                          /* 33222222222211111111110000000000
10631                                             10987654321098765432109876543210
10632                                             100001x1xxxxxxxx001xxxxxxxxxxxxx
10633                                             prfh.  */
10634                                          return 1782;
10635                                        }
10636                                      else
10637                                        {
10638                                          if (((word >> 22) & 0x1) == 0)
10639                                            {
10640                                              /* 33222222222211111111110000000000
10641                                                 10987654321098765432109876543210
10642                                                 100001x1x0xxxxxx101xxxxxxxxxxxxx
10643                                                 ldnt1w.  */
10644                                              return 2096;
10645                                            }
10646                                          else
10647                                            {
10648                                              if (((word >> 23) & 0x1) == 0)
10649                                                {
10650                                                  /* 33222222222211111111110000000000
10651                                                     10987654321098765432109876543210
10652                                                     100001x101xxxxxx101xxxxxxxxxxxxx
10653                                                     ld1rsh.  */
10654                                                  return 1554;
10655                                                }
10656                                              else
10657                                                {
10658                                                  /* 33222222222211111111110000000000
10659                                                     10987654321098765432109876543210
10660                                                     100001x111xxxxxx101xxxxxxxxxxxxx
10661                                                     ld1rsb.  */
10662                                                  return 1551;
10663                                                }
10664                                            }
10665                                        }
10666                                    }
10667                                  else
10668                                    {
10669                                      if (((word >> 15) & 0x1) == 0)
10670                                        {
10671                                          if (((word >> 23) & 0x1) == 0)
10672                                            {
10673                                              if (((word >> 21) & 0x1) == 0)
10674                                                {
10675                                                  /* 33222222222211111111110000000000
10676                                                     10987654321098765432109876543210
10677                                                     100001x10x0xxxxx011xxxxxxxxxxxxx
10678                                                     ldff1w.  */
10679                                                  return 1688;
10680                                                }
10681                                              else
10682                                                {
10683                                                  /* 33222222222211111111110000000000
10684                                                     10987654321098765432109876543210
10685                                                     100001x10x1xxxxx011xxxxxxxxxxxxx
10686                                                     ldff1w.  */
10687                                                  return 1689;
10688                                                }
10689                                            }
10690                                          else
10691                                            {
10692                                              /* 33222222222211111111110000000000
10693                                                 10987654321098765432109876543210
10694                                                 100001x11xxxxxxx011xxxxxxxxxxxxx
10695                                                 prfd.  */
10696                                              return 1775;
10697                                            }
10698                                        }
10699                                      else
10700                                        {
10701                                          if (((word >> 22) & 0x1) == 0)
10702                                            {
10703                                              if (((word >> 21) & 0x1) == 0)
10704                                                {
10705                                                  if (((word >> 23) & 0x1) == 0)
10706                                                    {
10707                                                      /* 33222222222211111111110000000000
10708                                                         10987654321098765432109876543210
10709                                                         100001x1000xxxxx111xxxxxxxxxxxxx
10710                                                         prfw.  */
10711                                                      return 1788;
10712                                                    }
10713                                                  else
10714                                                    {
10715                                                      /* 33222222222211111111110000000000
10716                                                         10987654321098765432109876543210
10717                                                         100001x1100xxxxx111xxxxxxxxxxxxx
10718                                                         prfd.  */
10719                                                      return 1774;
10720                                                    }
10721                                                }
10722                                              else
10723                                                {
10724                                                  /* 33222222222211111111110000000000
10725                                                     10987654321098765432109876543210
10726                                                     100001x1x01xxxxx111xxxxxxxxxxxxx
10727                                                     ldff1w.  */
10728                                                  return 1698;
10729                                                }
10730                                            }
10731                                          else
10732                                            {
10733                                              if (((word >> 23) & 0x1) == 0)
10734                                                {
10735                                                  /* 33222222222211111111110000000000
10736                                                     10987654321098765432109876543210
10737                                                     100001x101xxxxxx111xxxxxxxxxxxxx
10738                                                     ld1rw.  */
10739                                                  return 1557;
10740                                                }
10741                                              else
10742                                                {
10743                                                  /* 33222222222211111111110000000000
10744                                                     10987654321098765432109876543210
10745                                                     100001x111xxxxxx111xxxxxxxxxxxxx
10746                                                     ld1rd.  */
10747                                                  return 1538;
10748                                                }
10749                                            }
10750                                        }
10751                                    }
10752                                }
10753                            }
10754                        }
10755                      else
10756                        {
10757                          if (((word >> 13) & 0x1) == 0)
10758                            {
10759                              if (((word >> 14) & 0x1) == 0)
10760                                {
10761                                  if (((word >> 15) & 0x1) == 0)
10762                                    {
10763                                      if (((word >> 21) & 0x1) == 0)
10764                                        {
10765                                          if (((word >> 31) & 0x1) == 0)
10766                                            {
10767                                              if (((word >> 10) & 0x1) == 0)
10768                                                {
10769                                                  if (((word >> 11) & 0x1) == 0)
10770                                                    {
10771                                                      if (((word >> 12) & 0x1) == 0)
10772                                                        {
10773                                                          /* 33222222222211111111110000000000
10774                                                             10987654321098765432109876543210
10775                                                             010001x1xx0xxxxx000000xxxxxxxxxx
10776                                                             saddlb.  */
10777                                                          return 2126;
10778                                                        }
10779                                                      else
10780                                                        {
10781                                                          /* 33222222222211111111110000000000
10782                                                             10987654321098765432109876543210
10783                                                             010001x1xx0xxxxx000100xxxxxxxxxx
10784                                                             ssublb.  */
10785                                                          return 2233;
10786                                                        }
10787                                                    }
10788                                                  else
10789                                                    {
10790                                                      if (((word >> 12) & 0x1) == 0)
10791                                                        {
10792                                                          /* 33222222222211111111110000000000
10793                                                             10987654321098765432109876543210
10794                                                             010001x1xx0xxxxx000010xxxxxxxxxx
10795                                                             uaddlb.  */
10796                                                          return 2257;
10797                                                        }
10798                                                      else
10799                                                        {
10800                                                          /* 33222222222211111111110000000000
10801                                                             10987654321098765432109876543210
10802                                                             010001x1xx0xxxxx000110xxxxxxxxxx
10803                                                             usublb.  */
10804                                                          return 2310;
10805                                                        }
10806                                                    }
10807                                                }
10808                                              else
10809                                                {
10810                                                  if (((word >> 11) & 0x1) == 0)
10811                                                    {
10812                                                      if (((word >> 12) & 0x1) == 0)
10813                                                        {
10814                                                          /* 33222222222211111111110000000000
10815                                                             10987654321098765432109876543210
10816                                                             010001x1xx0xxxxx000001xxxxxxxxxx
10817                                                             saddlt.  */
10818                                                          return 2128;
10819                                                        }
10820                                                      else
10821                                                        {
10822                                                          /* 33222222222211111111110000000000
10823                                                             10987654321098765432109876543210
10824                                                             010001x1xx0xxxxx000101xxxxxxxxxx
10825                                                             ssublt.  */
10826                                                          return 2235;
10827                                                        }
10828                                                    }
10829                                                  else
10830                                                    {
10831                                                      if (((word >> 12) & 0x1) == 0)
10832                                                        {
10833                                                          /* 33222222222211111111110000000000
10834                                                             10987654321098765432109876543210
10835                                                             010001x1xx0xxxxx000011xxxxxxxxxx
10836                                                             uaddlt.  */
10837                                                          return 2258;
10838                                                        }
10839                                                      else
10840                                                        {
10841                                                          /* 33222222222211111111110000000000
10842                                                             10987654321098765432109876543210
10843                                                             010001x1xx0xxxxx000111xxxxxxxxxx
10844                                                             usublt.  */
10845                                                          return 2311;
10846                                                        }
10847                                                    }
10848                                                }
10849                                            }
10850                                          else
10851                                            {
10852                                              /* 33222222222211111111110000000000
10853                                                 10987654321098765432109876543210
10854                                                 110001x1xx0xxxxx000xxxxxxxxxxxxx
10855                                                 ld1sw.  */
10856                                              return 1582;
10857                                            }
10858                                        }
10859                                      else
10860                                        {
10861                                          if (((word >> 31) & 0x1) == 0)
10862                                            {
10863                                              if (((word >> 10) & 0x1) == 0)
10864                                                {
10865                                                  if (((word >> 11) & 0x1) == 0)
10866                                                    {
10867                                                      if (((word >> 12) & 0x1) == 0)
10868                                                        {
10869                                                          /* 33222222222211111111110000000000
10870                                                             10987654321098765432109876543210
10871                                                             010001x1xx1xxxxx000000xxxxxxxxxx
10872                                                             sqshrunb.  */
10873                                                          return 2216;
10874                                                        }
10875                                                      else
10876                                                        {
10877                                                          /* 33222222222211111111110000000000
10878                                                             10987654321098765432109876543210
10879                                                             010001x1xx1xxxxx000100xxxxxxxxxx
10880                                                             shrnb.  */
10881                                                          return 2134;
10882                                                        }
10883                                                    }
10884                                                  else
10885                                                    {
10886                                                      if (((word >> 12) & 0x1) == 0)
10887                                                        {
10888                                                          /* 33222222222211111111110000000000
10889                                                             10987654321098765432109876543210
10890                                                             010001x1xx1xxxxx000010xxxxxxxxxx
10891                                                             sqrshrunb.  */
10892                                                          return 2208;
10893                                                        }
10894                                                      else
10895                                                        {
10896                                                          /* 33222222222211111111110000000000
10897                                                             10987654321098765432109876543210
10898                                                             010001x1xx1xxxxx000110xxxxxxxxxx
10899                                                             rshrnb.  */
10900                                                          return 2116;
10901                                                        }
10902                                                    }
10903                                                }
10904                                              else
10905                                                {
10906                                                  if (((word >> 11) & 0x1) == 0)
10907                                                    {
10908                                                      if (((word >> 12) & 0x1) == 0)
10909                                                        {
10910                                                          /* 33222222222211111111110000000000
10911                                                             10987654321098765432109876543210
10912                                                             010001x1xx1xxxxx000001xxxxxxxxxx
10913                                                             sqshrunt.  */
10914                                                          return 2217;
10915                                                        }
10916                                                      else
10917                                                        {
10918                                                          /* 33222222222211111111110000000000
10919                                                             10987654321098765432109876543210
10920                                                             010001x1xx1xxxxx000101xxxxxxxxxx
10921                                                             shrnt.  */
10922                                                          return 2135;
10923                                                        }
10924                                                    }
10925                                                  else
10926                                                    {
10927                                                      if (((word >> 12) & 0x1) == 0)
10928                                                        {
10929                                                          /* 33222222222211111111110000000000
10930                                                             10987654321098765432109876543210
10931                                                             010001x1xx1xxxxx000011xxxxxxxxxx
10932                                                             sqrshrunt.  */
10933                                                          return 2209;
10934                                                        }
10935                                                      else
10936                                                        {
10937                                                          /* 33222222222211111111110000000000
10938                                                             10987654321098765432109876543210
10939                                                             010001x1xx1xxxxx000111xxxxxxxxxx
10940                                                             rshrnt.  */
10941                                                          return 2117;
10942                                                        }
10943                                                    }
10944                                                }
10945                                            }
10946                                          else
10947                                            {
10948                                              /* 33222222222211111111110000000000
10949                                                 10987654321098765432109876543210
10950                                                 110001x1xx1xxxxx000xxxxxxxxxxxxx
10951                                                 ld1sw.  */
10952                                              return 1583;
10953                                            }
10954                                        }
10955                                    }
10956                                  else
10957                                    {
10958                                      if (((word >> 21) & 0x1) == 0)
10959                                        {
10960                                          if (((word >> 31) & 0x1) == 0)
10961                                            {
10962                                              if (((word >> 10) & 0x1) == 0)
10963                                                {
10964                                                  if (((word >> 11) & 0x1) == 0)
10965                                                    {
10966                                                      if (((word >> 12) & 0x1) == 0)
10967                                                        {
10968                                                          /* 33222222222211111111110000000000
10969                                                             10987654321098765432109876543210
10970                                                             010001x1xx0xxxxx100000xxxxxxxxxx
10971                                                             saddlbt.  */
10972                                                          return 2127;
10973                                                        }
10974                                                      else
10975                                                        {
10976                                                          /* 33222222222211111111110000000000
10977                                                             10987654321098765432109876543210
10978                                                             010001x1xx0xxxxx100100xxxxxxxxxx
10979                                                             eorbt.  */
10980                                                          return 2063;
10981                                                        }
10982                                                    }
10983                                                  else
10984                                                    {
10985                                                      if (((word >> 12) & 0x1) == 0)
10986                                                        {
10987                                                          /* 33222222222211111111110000000000
10988                                                             10987654321098765432109876543210
10989                                                             010001x1xx0xxxxx100010xxxxxxxxxx
10990                                                             ssublbt.  */
10991                                                          return 2234;
10992                                                        }
10993                                                      else
10994                                                        {
10995                                                          if (((word >> 22) & 0x1) == 0)
10996                                                            {
10997                                                              if (((word >> 23) & 0x1) == 0)
10998                                                                {
10999                                                                  /* 33222222222211111111110000000000
11000                                                                     10987654321098765432109876543210
11001                                                                     010001x1000xxxxx100110xxxxxxxxxx
11002                                                                     smmla.  */
11003                                                                  return 2391;
11004                                                                }
11005                                                              else
11006                                                                {
11007                                                                  /* 33222222222211111111110000000000
11008                                                                     10987654321098765432109876543210
11009                                                                     010001x1100xxxxx100110xxxxxxxxxx
11010                                                                     usmmla.  */
11011                                                                  return 2393;
11012                                                                }
11013                                                            }
11014                                                          else
11015                                                            {
11016                                                              /* 33222222222211111111110000000000
11017                                                                 10987654321098765432109876543210
11018                                                                 010001x1x10xxxxx100110xxxxxxxxxx
11019                                                                 ummla.  */
11020                                                              return 2392;
11021                                                            }
11022                                                        }
11023                                                    }
11024                                                }
11025                                              else
11026                                                {
11027                                                  if (((word >> 11) & 0x1) == 0)
11028                                                    {
11029                                                      /* 33222222222211111111110000000000
11030                                                         10987654321098765432109876543210
11031                                                         010001x1xx0xxxxx100x01xxxxxxxxxx
11032                                                         eortb.  */
11033                                                      return 2064;
11034                                                    }
11035                                                  else
11036                                                    {
11037                                                      /* 33222222222211111111110000000000
11038                                                         10987654321098765432109876543210
11039                                                         010001x1xx0xxxxx100x11xxxxxxxxxx
11040                                                         ssubltb.  */
11041                                                      return 2236;
11042                                                    }
11043                                                }
11044                                            }
11045                                          else
11046                                            {
11047                                              if (((word >> 22) & 0x1) == 0)
11048                                                {
11049                                                  /* 33222222222211111111110000000000
11050                                                     10987654321098765432109876543210
11051                                                     110001x1x00xxxxx100xxxxxxxxxxxxx
11052                                                     ldnt1sw.  */
11053                                                  return 2095;
11054                                                }
11055                                              else
11056                                                {
11057                                                  /* 33222222222211111111110000000000
11058                                                     10987654321098765432109876543210
11059                                                     110001x1x10xxxxx100xxxxxxxxxxxxx
11060                                                     ld1sw.  */
11061                                                  return 1584;
11062                                                }
11063                                            }
11064                                        }
11065                                      else
11066                                        {
11067                                          if (((word >> 31) & 0x1) == 0)
11068                                            {
11069                                              if (((word >> 4) & 0x1) == 0)
11070                                                {
11071                                                  /* 33222222222211111111110000000000
11072                                                     10987654321098765432109876543210
11073                                                     010001x1xx1xxxxx100xxxxxxxx0xxxx
11074                                                     match.  */
11075                                                  return 2098;
11076                                                }
11077                                              else
11078                                                {
11079                                                  /* 33222222222211111111110000000000
11080                                                     10987654321098765432109876543210
11081                                                     010001x1xx1xxxxx100xxxxxxxx1xxxx
11082                                                     nmatch.  */
11083                                                  return 2110;
11084                                                }
11085                                            }
11086                                          else
11087                                            {
11088                                              if (((word >> 22) & 0x1) == 0)
11089                                                {
11090                                                  /* 33222222222211111111110000000000
11091                                                     10987654321098765432109876543210
11092                                                     110001x1x01xxxxx100xxxxxxxxxxxxx
11093                                                     ld1sw.  */
11094                                                  return 1587;
11095                                                }
11096                                              else
11097                                                {
11098                                                  /* 33222222222211111111110000000000
11099                                                     10987654321098765432109876543210
11100                                                     110001x1x11xxxxx100xxxxxxxxxxxxx
11101                                                     ld1sw.  */
11102                                                  return 1585;
11103                                                }
11104                                            }
11105                                        }
11106                                    }
11107                                }
11108                              else
11109                                {
11110                                  if (((word >> 15) & 0x1) == 0)
11111                                    {
11112                                      if (((word >> 21) & 0x1) == 0)
11113                                        {
11114                                          if (((word >> 31) & 0x1) == 0)
11115                                            {
11116                                              if (((word >> 10) & 0x1) == 0)
11117                                                {
11118                                                  if (((word >> 11) & 0x1) == 0)
11119                                                    {
11120                                                      if (((word >> 12) & 0x1) == 0)
11121                                                        {
11122                                                          /* 33222222222211111111110000000000
11123                                                             10987654321098765432109876543210
11124                                                             010001x1xx0xxxxx010000xxxxxxxxxx
11125                                                             saddwb.  */
11126                                                          return 2129;
11127                                                        }
11128                                                      else
11129                                                        {
11130                                                          /* 33222222222211111111110000000000
11131                                                             10987654321098765432109876543210
11132                                                             010001x1xx0xxxxx010100xxxxxxxxxx
11133                                                             ssubwb.  */
11134                                                          return 2237;
11135                                                        }
11136                                                    }
11137                                                  else
11138                                                    {
11139                                                      if (((word >> 12) & 0x1) == 0)
11140                                                        {
11141                                                          /* 33222222222211111111110000000000
11142                                                             10987654321098765432109876543210
11143                                                             010001x1xx0xxxxx010010xxxxxxxxxx
11144                                                             uaddwb.  */
11145                                                          return 2259;
11146                                                        }
11147                                                      else
11148                                                        {
11149                                                          /* 33222222222211111111110000000000
11150                                                             10987654321098765432109876543210
11151                                                             010001x1xx0xxxxx010110xxxxxxxxxx
11152                                                             usubwb.  */
11153                                                          return 2312;
11154                                                        }
11155                                                    }
11156                                                }
11157                                              else
11158                                                {
11159                                                  if (((word >> 11) & 0x1) == 0)
11160                                                    {
11161                                                      if (((word >> 12) & 0x1) == 0)
11162                                                        {
11163                                                          /* 33222222222211111111110000000000
11164                                                             10987654321098765432109876543210
11165                                                             010001x1xx0xxxxx010001xxxxxxxxxx
11166                                                             saddwt.  */
11167                                                          return 2130;
11168                                                        }
11169                                                      else
11170                                                        {
11171                                                          /* 33222222222211111111110000000000
11172                                                             10987654321098765432109876543210
11173                                                             010001x1xx0xxxxx010101xxxxxxxxxx
11174                                                             ssubwt.  */
11175                                                          return 2238;
11176                                                        }
11177                                                    }
11178                                                  else
11179                                                    {
11180                                                      if (((word >> 12) & 0x1) == 0)
11181                                                        {
11182                                                          /* 33222222222211111111110000000000
11183                                                             10987654321098765432109876543210
11184                                                             010001x1xx0xxxxx010011xxxxxxxxxx
11185                                                             uaddwt.  */
11186                                                          return 2260;
11187                                                        }
11188                                                      else
11189                                                        {
11190                                                          /* 33222222222211111111110000000000
11191                                                             10987654321098765432109876543210
11192                                                             010001x1xx0xxxxx010111xxxxxxxxxx
11193                                                             usubwt.  */
11194                                                          return 2313;
11195                                                        }
11196                                                    }
11197                                                }
11198                                            }
11199                                          else
11200                                            {
11201                                              if (((word >> 23) & 0x1) == 0)
11202                                                {
11203                                                  /* 33222222222211111111110000000000
11204                                                     10987654321098765432109876543210
11205                                                     110001x10x0xxxxx010xxxxxxxxxxxxx
11206                                                     ld1w.  */
11207                                                  return 1592;
11208                                                }
11209                                              else
11210                                                {
11211                                                  /* 33222222222211111111110000000000
11212                                                     10987654321098765432109876543210
11213                                                     110001x11x0xxxxx010xxxxxxxxxxxxx
11214                                                     ld1d.  */
11215                                                  return 1514;
11216                                                }
11217                                            }
11218                                        }
11219                                      else
11220                                        {
11221                                          if (((word >> 23) & 0x1) == 0)
11222                                            {
11223                                              if (((word >> 31) & 0x1) == 0)
11224                                                {
11225                                                  if (((word >> 10) & 0x1) == 0)
11226                                                    {
11227                                                      if (((word >> 11) & 0x1) == 0)
11228                                                        {
11229                                                          if (((word >> 12) & 0x1) == 0)
11230                                                            {
11231                                                              /* 33222222222211111111110000000000
11232                                                                 10987654321098765432109876543210
11233                                                                 010001x10x1xxxxx010000xxxxxxxxxx
11234                                                                 sqxtnb.  */
11235                                                              return 2220;
11236                                                            }
11237                                                          else
11238                                                            {
11239                                                              /* 33222222222211111111110000000000
11240                                                                 10987654321098765432109876543210
11241                                                                 010001x10x1xxxxx010100xxxxxxxxxx
11242                                                                 sqxtunb.  */
11243                                                              return 2222;
11244                                                            }
11245                                                        }
11246                                                      else
11247                                                        {
11248                                                          /* 33222222222211111111110000000000
11249                                                             10987654321098765432109876543210
11250                                                             010001x10x1xxxxx010x10xxxxxxxxxx
11251                                                             uqxtnb.  */
11252                                                          return 2297;
11253                                                        }
11254                                                    }
11255                                                  else
11256                                                    {
11257                                                      if (((word >> 11) & 0x1) == 0)
11258                                                        {
11259                                                          if (((word >> 12) & 0x1) == 0)
11260                                                            {
11261                                                              /* 33222222222211111111110000000000
11262                                                                 10987654321098765432109876543210
11263                                                                 010001x10x1xxxxx010001xxxxxxxxxx
11264                                                                 sqxtnt.  */
11265                                                              return 2221;
11266                                                            }
11267                                                          else
11268                                                            {
11269                                                              /* 33222222222211111111110000000000
11270                                                                 10987654321098765432109876543210
11271                                                                 010001x10x1xxxxx010101xxxxxxxxxx
11272                                                                 sqxtunt.  */
11273                                                              return 2223;
11274                                                            }
11275                                                        }
11276                                                      else
11277                                                        {
11278                                                          /* 33222222222211111111110000000000
11279                                                             10987654321098765432109876543210
11280                                                             010001x10x1xxxxx010x11xxxxxxxxxx
11281                                                             uqxtnt.  */
11282                                                          return 2298;
11283                                                        }
11284                                                    }
11285                                                }
11286                                              else
11287                                                {
11288                                                  /* 33222222222211111111110000000000
11289                                                     10987654321098765432109876543210
11290                                                     110001x10x1xxxxx010xxxxxxxxxxxxx
11291                                                     ld1w.  */
11292                                                  return 1593;
11293                                                }
11294                                            }
11295                                          else
11296                                            {
11297                                              /* 33222222222211111111110000000000
11298                                                 10987654321098765432109876543210
11299                                                 x10001x11x1xxxxx010xxxxxxxxxxxxx
11300                                                 ld1d.  */
11301                                              return 1515;
11302                                            }
11303                                        }
11304                                    }
11305                                  else
11306                                    {
11307                                      if (((word >> 21) & 0x1) == 0)
11308                                        {
11309                                          if (((word >> 31) & 0x1) == 0)
11310                                            {
11311                                              if (((word >> 11) & 0x1) == 0)
11312                                                {
11313                                                  if (((word >> 10) & 0x1) == 0)
11314                                                    {
11315                                                      if (((word >> 12) & 0x1) == 0)
11316                                                        {
11317                                                          /* 33222222222211111111110000000000
11318                                                             10987654321098765432109876543210
11319                                                             010001x1xx0xxxxx110000xxxxxxxxxx
11320                                                             sabalb.  */
11321                                                          return 2121;
11322                                                        }
11323                                                      else
11324                                                        {
11325                                                          if (((word >> 23) & 0x1) == 0)
11326                                                            {
11327                                                              /* 33222222222211111111110000000000
11328                                                                 10987654321098765432109876543210
11329                                                                 010001x10x0xxxxx110100xxxxxxxxxx
11330                                                                 adclb.  */
11331                                                              return 2046;
11332                                                            }
11333                                                          else
11334                                                            {
11335                                                              /* 33222222222211111111110000000000
11336                                                                 10987654321098765432109876543210
11337                                                                 010001x11x0xxxxx110100xxxxxxxxxx
11338                                                                 sbclb.  */
11339                                                              return 2131;
11340                                                            }
11341                                                        }
11342                                                    }
11343                                                  else
11344                                                    {
11345                                                      if (((word >> 12) & 0x1) == 0)
11346                                                        {
11347                                                          /* 33222222222211111111110000000000
11348                                                             10987654321098765432109876543210
11349                                                             010001x1xx0xxxxx110001xxxxxxxxxx
11350                                                             sabalt.  */
11351                                                          return 2122;
11352                                                        }
11353                                                      else
11354                                                        {
11355                                                          if (((word >> 23) & 0x1) == 0)
11356                                                            {
11357                                                              /* 33222222222211111111110000000000
11358                                                                 10987654321098765432109876543210
11359                                                                 010001x10x0xxxxx110101xxxxxxxxxx
11360                                                                 adclt.  */
11361                                                              return 2047;
11362                                                            }
11363                                                          else
11364                                                            {
11365                                                              /* 33222222222211111111110000000000
11366                                                                 10987654321098765432109876543210
11367                                                                 010001x11x0xxxxx110101xxxxxxxxxx
11368                                                                 sbclt.  */
11369                                                              return 2132;
11370                                                            }
11371                                                        }
11372                                                    }
11373                                                }
11374                                              else
11375                                                {
11376                                                  if (((word >> 12) & 0x1) == 0)
11377                                                    {
11378                                                      if (((word >> 10) & 0x1) == 0)
11379                                                        {
11380                                                          /* 33222222222211111111110000000000
11381                                                             10987654321098765432109876543210
11382                                                             010001x1xx0xxxxx110010xxxxxxxxxx
11383                                                             uabalb.  */
11384                                                          return 2252;
11385                                                        }
11386                                                      else
11387                                                        {
11388                                                          /* 33222222222211111111110000000000
11389                                                             10987654321098765432109876543210
11390                                                             010001x1xx0xxxxx110011xxxxxxxxxx
11391                                                             uabalt.  */
11392                                                          return 2253;
11393                                                        }
11394                                                    }
11395                                                  else
11396                                                    {
11397                                                      if (((word >> 16) & 0x1) == 0)
11398                                                        {
11399                                                          /* 33222222222211111111110000000000
11400                                                             10987654321098765432109876543210
11401                                                             010001x1xx0xxxx011011xxxxxxxxxxx
11402                                                             cadd.  */
11403                                                          return 2055;
11404                                                        }
11405                                                      else
11406                                                        {
11407                                                          /* 33222222222211111111110000000000
11408                                                             10987654321098765432109876543210
11409                                                             010001x1xx0xxxx111011xxxxxxxxxxx
11410                                                             sqcadd.  */
11411                                                          return 2163;
11412                                                        }
11413                                                    }
11414                                                }
11415                                            }
11416                                          else
11417                                            {
11418                                              if (((word >> 22) & 0x1) == 0)
11419                                                {
11420                                                  if (((word >> 23) & 0x1) == 0)
11421                                                    {
11422                                                      /* 33222222222211111111110000000000
11423                                                         10987654321098765432109876543210
11424                                                         110001x1000xxxxx110xxxxxxxxxxxxx
11425                                                         ldnt1w.  */
11426                                                      return 2097;
11427                                                    }
11428                                                  else
11429                                                    {
11430                                                      /* 33222222222211111111110000000000
11431                                                         10987654321098765432109876543210
11432                                                         110001x1100xxxxx110xxxxxxxxxxxxx
11433                                                         ldnt1d.  */
11434                                                      return 2090;
11435                                                    }
11436                                                }
11437                                              else
11438                                                {
11439                                                  if (((word >> 23) & 0x1) == 0)
11440                                                    {
11441                                                      /* 33222222222211111111110000000000
11442                                                         10987654321098765432109876543210
11443                                                         110001x1010xxxxx110xxxxxxxxxxxxx
11444                                                         ld1w.  */
11445                                                      return 1594;
11446                                                    }
11447                                                  else
11448                                                    {
11449                                                      /* 33222222222211111111110000000000
11450                                                         10987654321098765432109876543210
11451                                                         110001x1110xxxxx110xxxxxxxxxxxxx
11452                                                         ld1d.  */
11453                                                      return 1516;
11454                                                    }
11455                                                }
11456                                            }
11457                                        }
11458                                      else
11459                                        {
11460                                          if (((word >> 23) & 0x1) == 0)
11461                                            {
11462                                              if (((word >> 22) & 0x1) == 0)
11463                                                {
11464                                                  /* 33222222222211111111110000000000
11465                                                     10987654321098765432109876543210
11466                                                     x10001x1001xxxxx110xxxxxxxxxxxxx
11467                                                     ld1w.  */
11468                                                  return 1599;
11469                                                }
11470                                              else
11471                                                {
11472                                                  /* 33222222222211111111110000000000
11473                                                     10987654321098765432109876543210
11474                                                     x10001x1011xxxxx110xxxxxxxxxxxxx
11475                                                     ld1w.  */
11476                                                  return 1595;
11477                                                }
11478                                            }
11479                                          else
11480                                            {
11481                                              if (((word >> 31) & 0x1) == 0)
11482                                                {
11483                                                  /* 33222222222211111111110000000000
11484                                                     10987654321098765432109876543210
11485                                                     010001x11x1xxxxx110xxxxxxxxxxxxx
11486                                                     histcnt.  */
11487                                                  return 2086;
11488                                                }
11489                                              else
11490                                                {
11491                                                  if (((word >> 22) & 0x1) == 0)
11492                                                    {
11493                                                      /* 33222222222211111111110000000000
11494                                                         10987654321098765432109876543210
11495                                                         110001x1101xxxxx110xxxxxxxxxxxxx
11496                                                         ld1d.  */
11497                                                      return 1519;
11498                                                    }
11499                                                  else
11500                                                    {
11501                                                      /* 33222222222211111111110000000000
11502                                                         10987654321098765432109876543210
11503                                                         110001x1111xxxxx110xxxxxxxxxxxxx
11504                                                         ld1d.  */
11505                                                      return 1517;
11506                                                    }
11507                                                }
11508                                            }
11509                                        }
11510                                    }
11511                                }
11512                            }
11513                          else
11514                            {
11515                              if (((word >> 14) & 0x1) == 0)
11516                                {
11517                                  if (((word >> 15) & 0x1) == 0)
11518                                    {
11519                                      if (((word >> 21) & 0x1) == 0)
11520                                        {
11521                                          if (((word >> 31) & 0x1) == 0)
11522                                            {
11523                                              if (((word >> 10) & 0x1) == 0)
11524                                                {
11525                                                  if (((word >> 11) & 0x1) == 0)
11526                                                    {
11527                                                      /* 33222222222211111111110000000000
11528                                                         10987654321098765432109876543210
11529                                                         010001x1xx0xxxxx001x00xxxxxxxxxx
11530                                                         sabdlb.  */
11531                                                      return 2123;
11532                                                    }
11533                                                  else
11534                                                    {
11535                                                      /* 33222222222211111111110000000000
11536                                                         10987654321098765432109876543210
11537                                                         010001x1xx0xxxxx001x10xxxxxxxxxx
11538                                                         uabdlb.  */
11539                                                      return 2254;
11540                                                    }
11541                                                }
11542                                              else
11543                                                {
11544                                                  if (((word >> 11) & 0x1) == 0)
11545                                                    {
11546                                                      /* 33222222222211111111110000000000
11547                                                         10987654321098765432109876543210
11548                                                         010001x1xx0xxxxx001x01xxxxxxxxxx
11549                                                         sabdlt.  */
11550                                                      return 2124;
11551                                                    }
11552                                                  else
11553                                                    {
11554                                                      /* 33222222222211111111110000000000
11555                                                         10987654321098765432109876543210
11556                                                         010001x1xx0xxxxx001x11xxxxxxxxxx
11557                                                         uabdlt.  */
11558                                                      return 2255;
11559                                                    }
11560                                                }
11561                                            }
11562                                          else
11563                                            {
11564                                              /* 33222222222211111111110000000000
11565                                                 10987654321098765432109876543210
11566                                                 110001x1xx0xxxxx001xxxxxxxxxxxxx
11567                                                 ldff1sw.  */
11568                                              return 1683;
11569                                            }
11570                                        }
11571                                      else
11572                                        {
11573                                          if (((word >> 31) & 0x1) == 0)
11574                                            {
11575                                              if (((word >> 10) & 0x1) == 0)
11576                                                {
11577                                                  if (((word >> 11) & 0x1) == 0)
11578                                                    {
11579                                                      if (((word >> 12) & 0x1) == 0)
11580                                                        {
11581                                                          /* 33222222222211111111110000000000
11582                                                             10987654321098765432109876543210
11583                                                             010001x1xx1xxxxx001000xxxxxxxxxx
11584                                                             sqshrnb.  */
11585                                                          return 2214;
11586                                                        }
11587                                                      else
11588                                                        {
11589                                                          /* 33222222222211111111110000000000
11590                                                             10987654321098765432109876543210
11591                                                             010001x1xx1xxxxx001100xxxxxxxxxx
11592                                                             uqshrnb.  */
11593                                                          return 2293;
11594                                                        }
11595                                                    }
11596                                                  else
11597                                                    {
11598                                                      if (((word >> 12) & 0x1) == 0)
11599                                                        {
11600                                                          /* 33222222222211111111110000000000
11601                                                             10987654321098765432109876543210
11602                                                             010001x1xx1xxxxx001010xxxxxxxxxx
11603                                                             sqrshrnb.  */
11604                                                          return 2206;
11605                                                        }
11606                                                      else
11607                                                        {
11608                                                          /* 33222222222211111111110000000000
11609                                                             10987654321098765432109876543210
11610                                                             010001x1xx1xxxxx001110xxxxxxxxxx
11611                                                             uqrshrnb.  */
11612                                                          return 2288;
11613                                                        }
11614                                                    }
11615                                                }
11616                                              else
11617                                                {
11618                                                  if (((word >> 11) & 0x1) == 0)
11619                                                    {
11620                                                      if (((word >> 12) & 0x1) == 0)
11621                                                        {
11622                                                          /* 33222222222211111111110000000000
11623                                                             10987654321098765432109876543210
11624                                                             010001x1xx1xxxxx001001xxxxxxxxxx
11625                                                             sqshrnt.  */
11626                                                          return 2215;
11627                                                        }
11628                                                      else
11629                                                        {
11630                                                          /* 33222222222211111111110000000000
11631                                                             10987654321098765432109876543210
11632                                                             010001x1xx1xxxxx001101xxxxxxxxxx
11633                                                             uqshrnt.  */
11634                                                          return 2294;
11635                                                        }
11636                                                    }
11637                                                  else
11638                                                    {
11639                                                      if (((word >> 12) & 0x1) == 0)
11640                                                        {
11641                                                          /* 33222222222211111111110000000000
11642                                                             10987654321098765432109876543210
11643                                                             010001x1xx1xxxxx001011xxxxxxxxxx
11644                                                             sqrshrnt.  */
11645                                                          return 2207;
11646                                                        }
11647                                                      else
11648                                                        {
11649                                                          /* 33222222222211111111110000000000
11650                                                             10987654321098765432109876543210
11651                                                             010001x1xx1xxxxx001111xxxxxxxxxx
11652                                                             uqrshrnt.  */
11653                                                          return 2289;
11654                                                        }
11655                                                    }
11656                                                }
11657                                            }
11658                                          else
11659                                            {
11660                                              /* 33222222222211111111110000000000
11661                                                 10987654321098765432109876543210
11662                                                 110001x1xx1xxxxx001xxxxxxxxxxxxx
11663                                                 ldff1sw.  */
11664                                              return 1684;
11665                                            }
11666                                        }
11667                                    }
11668                                  else
11669                                    {
11670                                      if (((word >> 21) & 0x1) == 0)
11671                                        {
11672                                          if (((word >> 31) & 0x1) == 0)
11673                                            {
11674                                              if (((word >> 10) & 0x1) == 0)
11675                                                {
11676                                                  if (((word >> 11) & 0x1) == 0)
11677                                                    {
11678                                                      if (((word >> 12) & 0x1) == 0)
11679                                                        {
11680                                                          /* 33222222222211111111110000000000
11681                                                             10987654321098765432109876543210
11682                                                             010001x1xx0xxxxx101000xxxxxxxxxx
11683                                                             sshllb.  */
11684                                                          return 2230;
11685                                                        }
11686                                                      else
11687                                                        {
11688                                                          /* 33222222222211111111110000000000
11689                                                             10987654321098765432109876543210
11690                                                             010001x1xx0xxxxx101100xxxxxxxxxx
11691                                                             bext.  */
11692                                                          return 2335;
11693                                                        }
11694                                                    }
11695                                                  else
11696                                                    {
11697                                                      if (((word >> 12) & 0x1) == 0)
11698                                                        {
11699                                                          /* 33222222222211111111110000000000
11700                                                             10987654321098765432109876543210
11701                                                             010001x1xx0xxxxx101010xxxxxxxxxx
11702                                                             ushllb.  */
11703                                                          return 2306;
11704                                                        }
11705                                                      else
11706                                                        {
11707                                                          /* 33222222222211111111110000000000
11708                                                             10987654321098765432109876543210
11709                                                             010001x1xx0xxxxx101110xxxxxxxxxx
11710                                                             bgrp.  */
11711                                                          return 2336;
11712                                                        }
11713                                                    }
11714                                                }
11715                                              else
11716                                                {
11717                                                  if (((word >> 11) & 0x1) == 0)
11718                                                    {
11719                                                      if (((word >> 12) & 0x1) == 0)
11720                                                        {
11721                                                          /* 33222222222211111111110000000000
11722                                                             10987654321098765432109876543210
11723                                                             010001x1xx0xxxxx101001xxxxxxxxxx
11724                                                             sshllt.  */
11725                                                          return 2231;
11726                                                        }
11727                                                      else
11728                                                        {
11729                                                          /* 33222222222211111111110000000000
11730                                                             10987654321098765432109876543210
11731                                                             010001x1xx0xxxxx101101xxxxxxxxxx
11732                                                             bdep.  */
11733                                                          return 2334;
11734                                                        }
11735                                                    }
11736                                                  else
11737                                                    {
11738                                                      /* 33222222222211111111110000000000
11739                                                         10987654321098765432109876543210
11740                                                         010001x1xx0xxxxx101x11xxxxxxxxxx
11741                                                         ushllt.  */
11742                                                      return 2307;
11743                                                    }
11744                                                }
11745                                            }
11746                                          else
11747                                            {
11748                                              /* 33222222222211111111110000000000
11749                                                 10987654321098765432109876543210
11750                                                 110001x1xx0xxxxx101xxxxxxxxxxxxx
11751                                                 ldff1sw.  */
11752                                              return 1685;
11753                                            }
11754                                        }
11755                                      else
11756                                        {
11757                                          if (((word >> 22) & 0x1) == 0)
11758                                            {
11759                                              if (((word >> 31) & 0x1) == 0)
11760                                                {
11761                                                  /* 33222222222211111111110000000000
11762                                                     10987654321098765432109876543210
11763                                                     010001x1x01xxxxx101xxxxxxxxxxxxx
11764                                                     histseg.  */
11765                                                  return 2087;
11766                                                }
11767                                              else
11768                                                {
11769                                                  /* 33222222222211111111110000000000
11770                                                     10987654321098765432109876543210
11771                                                     110001x1x01xxxxx101xxxxxxxxxxxxx
11772                                                     ldff1sw.  */
11773                                                  return 1687;
11774                                                }
11775                                            }
11776                                          else
11777                                            {
11778                                              /* 33222222222211111111110000000000
11779                                                 10987654321098765432109876543210
11780                                                 x10001x1x11xxxxx101xxxxxxxxxxxxx
11781                                                 ldff1sw.  */
11782                                              return 1686;
11783                                            }
11784                                        }
11785                                    }
11786                                }
11787                              else
11788                                {
11789                                  if (((word >> 15) & 0x1) == 0)
11790                                    {
11791                                      if (((word >> 21) & 0x1) == 0)
11792                                        {
11793                                          if (((word >> 31) & 0x1) == 0)
11794                                            {
11795                                              if (((word >> 10) & 0x1) == 0)
11796                                                {
11797                                                  if (((word >> 11) & 0x1) == 0)
11798                                                    {
11799                                                      if (((word >> 12) & 0x1) == 0)
11800                                                        {
11801                                                          /* 33222222222211111111110000000000
11802                                                             10987654321098765432109876543210
11803                                                             010001x1xx0xxxxx011000xxxxxxxxxx
11804                                                             sqdmullb.  */
11805                                                          return 2184;
11806                                                        }
11807                                                      else
11808                                                        {
11809                                                          /* 33222222222211111111110000000000
11810                                                             10987654321098765432109876543210
11811                                                             010001x1xx0xxxxx011100xxxxxxxxxx
11812                                                             smullb.  */
11813                                                          return 2156;
11814                                                        }
11815                                                    }
11816                                                  else
11817                                                    {
11818                                                      if (((word >> 12) & 0x1) == 0)
11819                                                        {
11820                                                          if (((word >> 22) & 0x1) == 0)
11821                                                            {
11822                                                              /* 33222222222211111111110000000000
11823                                                                 10987654321098765432109876543210
11824                                                                 010001x1x00xxxxx011010xxxxxxxxxx
11825                                                                 pmullb.  */
11826                                                              return 2331;
11827                                                            }
11828                                                          else
11829                                                            {
11830                                                              /* 33222222222211111111110000000000
11831                                                                 10987654321098765432109876543210
11832                                                                 010001x1x10xxxxx011010xxxxxxxxxx
11833                                                                 pmullb.  */
11834                                                              return 2112;
11835                                                            }
11836                                                        }
11837                                                      else
11838                                                        {
11839                                                          /* 33222222222211111111110000000000
11840                                                             10987654321098765432109876543210
11841                                                             010001x1xx0xxxxx011110xxxxxxxxxx
11842                                                             umullb.  */
11843                                                          return 2281;
11844                                                        }
11845                                                    }
11846                                                }
11847                                              else
11848                                                {
11849                                                  if (((word >> 11) & 0x1) == 0)
11850                                                    {
11851                                                      if (((word >> 12) & 0x1) == 0)
11852                                                        {
11853                                                          /* 33222222222211111111110000000000
11854                                                             10987654321098765432109876543210
11855                                                             010001x1xx0xxxxx011001xxxxxxxxxx
11856                                                             sqdmullt.  */
11857                                                          return 2187;
11858                                                        }
11859                                                      else
11860                                                        {
11861                                                          /* 33222222222211111111110000000000
11862                                                             10987654321098765432109876543210
11863                                                             010001x1xx0xxxxx011101xxxxxxxxxx
11864                                                             smullt.  */
11865                                                          return 2159;
11866                                                        }
11867                                                    }
11868                                                  else
11869                                                    {
11870                                                      if (((word >> 12) & 0x1) == 0)
11871                                                        {
11872                                                          if (((word >> 22) & 0x1) == 0)
11873                                                            {
11874                                                              /* 33222222222211111111110000000000
11875                                                                 10987654321098765432109876543210
11876                                                                 010001x1x00xxxxx011011xxxxxxxxxx
11877                                                                 pmullt.  */
11878                                                              return 2332;
11879                                                            }
11880                                                          else
11881                                                            {
11882                                                              /* 33222222222211111111110000000000
11883                                                                 10987654321098765432109876543210
11884                                                                 010001x1x10xxxxx011011xxxxxxxxxx
11885                                                                 pmullt.  */
11886                                                              return 2113;
11887                                                            }
11888                                                        }
11889                                                      else
11890                                                        {
11891                                                          /* 33222222222211111111110000000000
11892                                                             10987654321098765432109876543210
11893                                                             010001x1xx0xxxxx011111xxxxxxxxxx
11894                                                             umullt.  */
11895                                                          return 2284;
11896                                                        }
11897                                                    }
11898                                                }
11899                                            }
11900                                          else
11901                                            {
11902                                              if (((word >> 23) & 0x1) == 0)
11903                                                {
11904                                                  /* 33222222222211111111110000000000
11905                                                     10987654321098765432109876543210
11906                                                     110001x10x0xxxxx011xxxxxxxxxxxxx
11907                                                     ldff1w.  */
11908                                                  return 1694;
11909                                                }
11910                                              else
11911                                                {
11912                                                  /* 33222222222211111111110000000000
11913                                                     10987654321098765432109876543210
11914                                                     110001x11x0xxxxx011xxxxxxxxxxxxx
11915                                                     ldff1d.  */
11916                                                  return 1639;
11917                                                }
11918                                            }
11919                                        }
11920                                      else
11921                                        {
11922                                          if (((word >> 31) & 0x1) == 0)
11923                                            {
11924                                              if (((word >> 10) & 0x1) == 0)
11925                                                {
11926                                                  if (((word >> 11) & 0x1) == 0)
11927                                                    {
11928                                                      if (((word >> 12) & 0x1) == 0)
11929                                                        {
11930                                                          /* 33222222222211111111110000000000
11931                                                             10987654321098765432109876543210
11932                                                             010001x1xx1xxxxx011000xxxxxxxxxx
11933                                                             addhnb.  */
11934                                                          return 2048;
11935                                                        }
11936                                                      else
11937                                                        {
11938                                                          /* 33222222222211111111110000000000
11939                                                             10987654321098765432109876543210
11940                                                             010001x1xx1xxxxx011100xxxxxxxxxx
11941                                                             subhnb.  */
11942                                                          return 2246;
11943                                                        }
11944                                                    }
11945                                                  else
11946                                                    {
11947                                                      if (((word >> 12) & 0x1) == 0)
11948                                                        {
11949                                                          /* 33222222222211111111110000000000
11950                                                             10987654321098765432109876543210
11951                                                             010001x1xx1xxxxx011010xxxxxxxxxx
11952                                                             raddhnb.  */
11953                                                          return 2114;
11954                                                        }
11955                                                      else
11956                                                        {
11957                                                          /* 33222222222211111111110000000000
11958                                                             10987654321098765432109876543210
11959                                                             010001x1xx1xxxxx011110xxxxxxxxxx
11960                                                             rsubhnb.  */
11961                                                          return 2118;
11962                                                        }
11963                                                    }
11964                                                }
11965                                              else
11966                                                {
11967                                                  if (((word >> 11) & 0x1) == 0)
11968                                                    {
11969                                                      if (((word >> 12) & 0x1) == 0)
11970                                                        {
11971                                                          /* 33222222222211111111110000000000
11972                                                             10987654321098765432109876543210
11973                                                             010001x1xx1xxxxx011001xxxxxxxxxx
11974                                                             addhnt.  */
11975                                                          return 2049;
11976                                                        }
11977                                                      else
11978                                                        {
11979                                                          /* 33222222222211111111110000000000
11980                                                             10987654321098765432109876543210
11981                                                             010001x1xx1xxxxx011101xxxxxxxxxx
11982                                                             subhnt.  */
11983                                                          return 2247;
11984                                                        }
11985                                                    }
11986                                                  else
11987                                                    {
11988                                                      if (((word >> 12) & 0x1) == 0)
11989                                                        {
11990                                                          /* 33222222222211111111110000000000
11991                                                             10987654321098765432109876543210
11992                                                             010001x1xx1xxxxx011011xxxxxxxxxx
11993                                                             raddhnt.  */
11994                                                          return 2115;
11995                                                        }
11996                                                      else
11997                                                        {
11998                                                          /* 33222222222211111111110000000000
11999                                                             10987654321098765432109876543210
12000                                                             010001x1xx1xxxxx011111xxxxxxxxxx
12001                                                             rsubhnt.  */
12002                                                          return 2119;
12003                                                        }
12004                                                    }
12005                                                }
12006                                            }
12007                                          else
12008                                            {
12009                                              if (((word >> 23) & 0x1) == 0)
12010                                                {
12011                                                  /* 33222222222211111111110000000000
12012                                                     10987654321098765432109876543210
12013                                                     110001x10x1xxxxx011xxxxxxxxxxxxx
12014                                                     ldff1w.  */
12015                                                  return 1695;
12016                                                }
12017                                              else
12018                                                {
12019                                                  /* 33222222222211111111110000000000
12020                                                     10987654321098765432109876543210
12021                                                     110001x11x1xxxxx011xxxxxxxxxxxxx
12022                                                     ldff1d.  */
12023                                                  return 1640;
12024                                                }
12025                                            }
12026                                        }
12027                                    }
12028                                  else
12029                                    {
12030                                      if (((word >> 21) & 0x1) == 0)
12031                                        {
12032                                          if (((word >> 31) & 0x1) == 0)
12033                                            {
12034                                              if (((word >> 10) & 0x1) == 0)
12035                                                {
12036                                                  if (((word >> 11) & 0x1) == 0)
12037                                                    {
12038                                                      if (((word >> 12) & 0x1) == 0)
12039                                                        {
12040                                                          /* 33222222222211111111110000000000
12041                                                             10987654321098765432109876543210
12042                                                             010001x1xx0xxxxx111000xxxxxxxxxx
12043                                                             ssra.  */
12044                                                          return 2232;
12045                                                        }
12046                                                      else
12047                                                        {
12048                                                          /* 33222222222211111111110000000000
12049                                                             10987654321098765432109876543210
12050                                                             010001x1xx0xxxxx111100xxxxxxxxxx
12051                                                             sri.  */
12052                                                          return 2225;
12053                                                        }
12054                                                    }
12055                                                  else
12056                                                    {
12057                                                      if (((word >> 12) & 0x1) == 0)
12058                                                        {
12059                                                          /* 33222222222211111111110000000000
12060                                                             10987654321098765432109876543210
12061                                                             010001x1xx0xxxxx111010xxxxxxxxxx
12062                                                             srsra.  */
12063                                                          return 2229;
12064                                                        }
12065                                                      else
12066                                                        {
12067                                                          /* 33222222222211111111110000000000
12068                                                             10987654321098765432109876543210
12069                                                             010001x1xx0xxxxx111110xxxxxxxxxx
12070                                                             saba.  */
12071                                                          return 2120;
12072                                                        }
12073                                                    }
12074                                                }
12075                                              else
12076                                                {
12077                                                  if (((word >> 11) & 0x1) == 0)
12078                                                    {
12079                                                      if (((word >> 12) & 0x1) == 0)
12080                                                        {
12081                                                          /* 33222222222211111111110000000000
12082                                                             10987654321098765432109876543210
12083                                                             010001x1xx0xxxxx111001xxxxxxxxxx
12084                                                             usra.  */
12085                                                          return 2309;
12086                                                        }
12087                                                      else
12088                                                        {
12089                                                          /* 33222222222211111111110000000000
12090                                                             10987654321098765432109876543210
12091                                                             010001x1xx0xxxxx111101xxxxxxxxxx
12092                                                             sli.  */
12093                                                          return 2138;
12094                                                        }
12095                                                    }
12096                                                  else
12097                                                    {
12098                                                      if (((word >> 12) & 0x1) == 0)
12099                                                        {
12100                                                          /* 33222222222211111111110000000000
12101                                                             10987654321098765432109876543210
12102                                                             010001x1xx0xxxxx111011xxxxxxxxxx
12103                                                             ursra.  */
12104                                                          return 2305;
12105                                                        }
12106                                                      else
12107                                                        {
12108                                                          /* 33222222222211111111110000000000
12109                                                             10987654321098765432109876543210
12110                                                             010001x1xx0xxxxx111111xxxxxxxxxx
12111                                                             uaba.  */
12112                                                          return 2251;
12113                                                        }
12114                                                    }
12115                                                }
12116                                            }
12117                                          else
12118                                            {
12119                                              if (((word >> 22) & 0x1) == 0)
12120                                                {
12121                                                  if (((word >> 23) & 0x1) == 0)
12122                                                    {
12123                                                      /* 33222222222211111111110000000000
12124                                                         10987654321098765432109876543210
12125                                                         110001x1000xxxxx111xxxxxxxxxxxxx
12126                                                         prfw.  */
12127                                                      return 1790;
12128                                                    }
12129                                                  else
12130                                                    {
12131                                                      /* 33222222222211111111110000000000
12132                                                         10987654321098765432109876543210
12133                                                         110001x1100xxxxx111xxxxxxxxxxxxx
12134                                                         prfd.  */
12135                                                      return 1776;
12136                                                    }
12137                                                }
12138                                              else
12139                                                {
12140                                                  if (((word >> 23) & 0x1) == 0)
12141                                                    {
12142                                                      /* 33222222222211111111110000000000
12143                                                         10987654321098765432109876543210
12144                                                         110001x1010xxxxx111xxxxxxxxxxxxx
12145                                                         ldff1w.  */
12146                                                      return 1696;
12147                                                    }
12148                                                  else
12149                                                    {
12150                                                      /* 33222222222211111111110000000000
12151                                                         10987654321098765432109876543210
12152                                                         110001x1110xxxxx111xxxxxxxxxxxxx
12153                                                         ldff1d.  */
12154                                                      return 1641;
12155                                                    }
12156                                                }
12157                                            }
12158                                        }
12159                                      else
12160                                        {
12161                                          if (((word >> 22) & 0x1) == 0)
12162                                            {
12163                                              if (((word >> 23) & 0x1) == 0)
12164                                                {
12165                                                  if (((word >> 31) & 0x1) == 0)
12166                                                    {
12167                                                      if (((word >> 10) & 0x1) == 0)
12168                                                        {
12169                                                          if (((word >> 12) & 0x1) == 0)
12170                                                            {
12171                                                              if (((word >> 16) & 0x1) == 0)
12172                                                                {
12173                                                                  if (((word >> 17) & 0x1) == 0)
12174                                                                    {
12175                                                                      /* 33222222222211111111110000000000
12176                                                                         10987654321098765432109876543210
12177                                                                         010001x1001xxx001110x0xxxxxxxxxx
12178                                                                         aesmc.  */
12179                                                                      return 2330;
12180                                                                    }
12181                                                                  else
12182                                                                    {
12183                                                                      /* 33222222222211111111110000000000
12184                                                                         10987654321098765432109876543210
12185                                                                         010001x1001xxx101110x0xxxxxxxxxx
12186                                                                         aese.  */
12187                                                                      return 2328;
12188                                                                    }
12189                                                                }
12190                                                              else
12191                                                                {
12192                                                                  /* 33222222222211111111110000000000
12193                                                                     10987654321098765432109876543210
12194                                                                     010001x1001xxxx11110x0xxxxxxxxxx
12195                                                                     sm4e.  */
12196                                                                  return 2325;
12197                                                                }
12198                                                            }
12199                                                          else
12200                                                            {
12201                                                              /* 33222222222211111111110000000000
12202                                                                 10987654321098765432109876543210
12203                                                                 010001x1001xxxxx1111x0xxxxxxxxxx
12204                                                                 sm4ekey.  */
12205                                                              return 2326;
12206                                                            }
12207                                                        }
12208                                                      else
12209                                                        {
12210                                                          if (((word >> 12) & 0x1) == 0)
12211                                                            {
12212                                                              if (((word >> 17) & 0x1) == 0)
12213                                                                {
12214                                                                  /* 33222222222211111111110000000000
12215                                                                     10987654321098765432109876543210
12216                                                                     010001x1001xxx0x1110x1xxxxxxxxxx
12217                                                                     aesimc.  */
12218                                                                  return 2329;
12219                                                                }
12220                                                              else
12221                                                                {
12222                                                                  /* 33222222222211111111110000000000
12223                                                                     10987654321098765432109876543210
12224                                                                     010001x1001xxx1x1110x1xxxxxxxxxx
12225                                                                     aesd.  */
12226                                                                  return 2327;
12227                                                                }
12228                                                            }
12229                                                          else
12230                                                            {
12231                                                              /* 33222222222211111111110000000000
12232                                                                 10987654321098765432109876543210
12233                                                                 010001x1001xxxxx1111x1xxxxxxxxxx
12234                                                                 rax1.  */
12235                                                              return 2333;
12236                                                            }
12237                                                        }
12238                                                    }
12239                                                  else
12240                                                    {
12241                                                      /* 33222222222211111111110000000000
12242                                                         10987654321098765432109876543210
12243                                                         110001x1001xxxxx111xxxxxxxxxxxxx
12244                                                         ldff1w.  */
12245                                                      return 1699;
12246                                                    }
12247                                                }
12248                                              else
12249                                                {
12250                                                  /* 33222222222211111111110000000000
12251                                                     10987654321098765432109876543210
12252                                                     x10001x1101xxxxx111xxxxxxxxxxxxx
12253                                                     ldff1d.  */
12254                                                  return 1643;
12255                                                }
12256                                            }
12257                                          else
12258                                            {
12259                                              if (((word >> 23) & 0x1) == 0)
12260                                                {
12261                                                  /* 33222222222211111111110000000000
12262                                                     10987654321098765432109876543210
12263                                                     x10001x1011xxxxx111xxxxxxxxxxxxx
12264                                                     ldff1w.  */
12265                                                  return 1697;
12266                                                }
12267                                              else
12268                                                {
12269                                                  /* 33222222222211111111110000000000
12270                                                     10987654321098765432109876543210
12271                                                     x10001x1111xxxxx111xxxxxxxxxxxxx
12272                                                     ldff1d.  */
12273                                                  return 1642;
12274                                                }
12275                                            }
12276                                        }
12277                                    }
12278                                }
12279                            }
12280                        }
12281                    }
12282                  else
12283                    {
12284                      if (((word >> 15) & 0x1) == 0)
12285                        {
12286                          if (((word >> 14) & 0x1) == 0)
12287                            {
12288                              if (((word >> 13) & 0x1) == 0)
12289                                {
12290                                  if (((word >> 30) & 0x1) == 0)
12291                                    {
12292                                      if (((word >> 21) & 0x1) == 0)
12293                                        {
12294                                          if (((word >> 31) & 0x1) == 0)
12295                                            {
12296                                              if (((word >> 4) & 0x1) == 0)
12297                                                {
12298                                                  /* 33222222222211111111110000000000
12299                                                     10987654321098765432109876543210
12300                                                     001001x1xx0xxxxx000xxxxxxxx0xxxx
12301                                                     cmpge.  */
12302                                                  return 1322;
12303                                                }
12304                                              else
12305                                                {
12306                                                  /* 33222222222211111111110000000000
12307                                                     10987654321098765432109876543210
12308                                                     001001x1xx0xxxxx000xxxxxxxx1xxxx
12309                                                     cmpgt.  */
12310                                                  return 1325;
12311                                                }
12312                                            }
12313                                          else
12314                                            {
12315                                              if (((word >> 23) & 0x1) == 0)
12316                                                {
12317                                                  /* 33222222222211111111110000000000
12318                                                     10987654321098765432109876543210
12319                                                     101001x10x0xxxxx000xxxxxxxxxxxxx
12320                                                     ld1rqw.  */
12321                                                  return 1549;
12322                                                }
12323                                              else
12324                                                {
12325                                                  /* 33222222222211111111110000000000
12326                                                     10987654321098765432109876543210
12327                                                     101001x11x0xxxxx000xxxxxxxxxxxxx
12328                                                     ld1rqd.  */
12329                                                  return 1545;
12330                                                }
12331                                            }
12332                                        }
12333                                      else
12334                                        {
12335                                          if (((word >> 31) & 0x1) == 0)
12336                                            {
12337                                              if (((word >> 4) & 0x1) == 0)
12338                                                {
12339                                                  if (((word >> 10) & 0x1) == 0)
12340                                                    {
12341                                                      if (((word >> 11) & 0x1) == 0)
12342                                                        {
12343                                                          if (((word >> 12) & 0x1) == 0)
12344                                                            {
12345                                                              /* 33222222222211111111110000000000
12346                                                                 10987654321098765432109876543210
12347                                                                 001001x1xx1xxxxx000000xxxxx0xxxx
12348                                                                 whilege.  */
12349                                                              return 2314;
12350                                                            }
12351                                                          else
12352                                                            {
12353                                                              /* 33222222222211111111110000000000
12354                                                                 10987654321098765432109876543210
12355                                                                 001001x1xx1xxxxx000100xxxxx0xxxx
12356                                                                 whilege.  */
12357                                                              return 2315;
12358                                                            }
12359                                                        }
12360                                                      else
12361                                                        {
12362                                                          if (((word >> 12) & 0x1) == 0)
12363                                                            {
12364                                                              /* 33222222222211111111110000000000
12365                                                                 10987654321098765432109876543210
12366                                                                 001001x1xx1xxxxx000010xxxxx0xxxx
12367                                                                 whilehs.  */
12368                                                              return 2320;
12369                                                            }
12370                                                          else
12371                                                            {
12372                                                              /* 33222222222211111111110000000000
12373                                                                 10987654321098765432109876543210
12374                                                                 001001x1xx1xxxxx000110xxxxx0xxxx
12375                                                                 whilehs.  */
12376                                                              return 2321;
12377                                                            }
12378                                                        }
12379                                                    }
12380                                                  else
12381                                                    {
12382                                                      if (((word >> 11) & 0x1) == 0)
12383                                                        {
12384                                                          if (((word >> 12) & 0x1) == 0)
12385                                                            {
12386                                                              /* 33222222222211111111110000000000
12387                                                                 10987654321098765432109876543210
12388                                                                 001001x1xx1xxxxx000001xxxxx0xxxx
12389                                                                 whilelt.  */
12390                                                              return 2026;
12391                                                            }
12392                                                          else
12393                                                            {
12394                                                              /* 33222222222211111111110000000000
12395                                                                 10987654321098765432109876543210
12396                                                                 001001x1xx1xxxxx000101xxxxx0xxxx
12397                                                                 whilelt.  */
12398                                                              return 2027;
12399                                                            }
12400                                                        }
12401                                                      else
12402                                                        {
12403                                                          if (((word >> 12) & 0x1) == 0)
12404                                                            {
12405                                                              /* 33222222222211111111110000000000
12406                                                                 10987654321098765432109876543210
12407                                                                 001001x1xx1xxxxx000011xxxxx0xxxx
12408                                                                 whilelo.  */
12409                                                              return 2022;
12410                                                            }
12411                                                          else
12412                                                            {
12413                                                              /* 33222222222211111111110000000000
12414                                                                 10987654321098765432109876543210
12415                                                                 001001x1xx1xxxxx000111xxxxx0xxxx
12416                                                                 whilelo.  */
12417                                                              return 2023;
12418                                                            }
12419                                                        }
12420                                                    }
12421                                                }
12422                                              else
12423                                                {
12424                                                  if (((word >> 10) & 0x1) == 0)
12425                                                    {
12426                                                      if (((word >> 11) & 0x1) == 0)
12427                                                        {
12428                                                          if (((word >> 12) & 0x1) == 0)
12429                                                            {
12430                                                              /* 33222222222211111111110000000000
12431                                                                 10987654321098765432109876543210
12432                                                                 001001x1xx1xxxxx000000xxxxx1xxxx
12433                                                                 whilegt.  */
12434                                                              return 2316;
12435                                                            }
12436                                                          else
12437                                                            {
12438                                                              /* 33222222222211111111110000000000
12439                                                                 10987654321098765432109876543210
12440                                                                 001001x1xx1xxxxx000100xxxxx1xxxx
12441                                                                 whilegt.  */
12442                                                              return 2317;
12443                                                            }
12444                                                        }
12445                                                      else
12446                                                        {
12447                                                          if (((word >> 12) & 0x1) == 0)
12448                                                            {
12449                                                              /* 33222222222211111111110000000000
12450                                                                 10987654321098765432109876543210
12451                                                                 001001x1xx1xxxxx000010xxxxx1xxxx
12452                                                                 whilehi.  */
12453                                                              return 2318;
12454                                                            }
12455                                                          else
12456                                                            {
12457                                                              /* 33222222222211111111110000000000
12458                                                                 10987654321098765432109876543210
12459                                                                 001001x1xx1xxxxx000110xxxxx1xxxx
12460                                                                 whilehi.  */
12461                                                              return 2319;
12462                                                            }
12463                                                        }
12464                                                    }
12465                                                  else
12466                                                    {
12467                                                      if (((word >> 11) & 0x1) == 0)
12468                                                        {
12469                                                          if (((word >> 12) & 0x1) == 0)
12470                                                            {
12471                                                              /* 33222222222211111111110000000000
12472                                                                 10987654321098765432109876543210
12473                                                                 001001x1xx1xxxxx000001xxxxx1xxxx
12474                                                                 whilele.  */
12475                                                              return 2020;
12476                                                            }
12477                                                          else
12478                                                            {
12479                                                              /* 33222222222211111111110000000000
12480                                                                 10987654321098765432109876543210
12481                                                                 001001x1xx1xxxxx000101xxxxx1xxxx
12482                                                                 whilele.  */
12483                                                              return 2021;
12484                                                            }
12485                                                        }
12486                                                      else
12487                                                        {
12488                                                          if (((word >> 12) & 0x1) == 0)
12489                                                            {
12490                                                              /* 33222222222211111111110000000000
12491                                                                 10987654321098765432109876543210
12492                                                                 001001x1xx1xxxxx000011xxxxx1xxxx
12493                                                                 whilels.  */
12494                                                              return 2024;
12495                                                            }
12496                                                          else
12497                                                            {
12498                                                              /* 33222222222211111111110000000000
12499                                                                 10987654321098765432109876543210
12500                                                                 001001x1xx1xxxxx000111xxxxx1xxxx
12501                                                                 whilels.  */
12502                                                              return 2025;
12503                                                            }
12504                                                        }
12505                                                    }
12506                                                }
12507                                            }
12508                                          else
12509                                            {
12510                                              if (((word >> 23) & 0x1) == 0)
12511                                                {
12512                                                  /* 33222222222211111111110000000000
12513                                                     10987654321098765432109876543210
12514                                                     101001x10x1xxxxx000xxxxxxxxxxxxx
12515                                                     ld1row.  */
12516                                                  return 2401;
12517                                                }
12518                                              else
12519                                                {
12520                                                  /* 33222222222211111111110000000000
12521                                                     10987654321098765432109876543210
12522                                                     101001x11x1xxxxx000xxxxxxxxxxxxx
12523                                                     ld1rod.  */
12524                                                  return 2402;
12525                                                }
12526                                            }
12527                                        }
12528                                    }
12529                                  else
12530                                    {
12531                                      if (((word >> 31) & 0x1) == 0)
12532                                        {
12533                                          if (((word >> 21) & 0x1) == 0)
12534                                            {
12535                                              if (((word >> 10) & 0x1) == 0)
12536                                                {
12537                                                  if (((word >> 11) & 0x1) == 0)
12538                                                    {
12539                                                      /* 33222222222211111111110000000000
12540                                                         10987654321098765432109876543210
12541                                                         011001x1xx0xxxxx000x00xxxxxxxxxx
12542                                                         fadd.  */
12543                                                      return 1380;
12544                                                    }
12545                                                  else
12546                                                    {
12547                                                      if (((word >> 12) & 0x1) == 0)
12548                                                        {
12549                                                          /* 33222222222211111111110000000000
12550                                                             10987654321098765432109876543210
12551                                                             011001x1xx0xxxxx000010xxxxxxxxxx
12552                                                             fmul.  */
12553                                                          return 1447;
12554                                                        }
12555                                                      else
12556                                                        {
12557                                                          /* 33222222222211111111110000000000
12558                                                             10987654321098765432109876543210
12559                                                             011001x1xx0xxxxx000110xxxxxxxxxx
12560                                                             frecps.  */
12561                                                          return 1460;
12562                                                        }
12563                                                    }
12564                                                }
12565                                              else
12566                                                {
12567                                                  if (((word >> 11) & 0x1) == 0)
12568                                                    {
12569                                                      /* 33222222222211111111110000000000
12570                                                         10987654321098765432109876543210
12571                                                         011001x1xx0xxxxx000x01xxxxxxxxxx
12572                                                         fsub.  */
12573                                                      return 1473;
12574                                                    }
12575                                                  else
12576                                                    {
12577                                                      if (((word >> 12) & 0x1) == 0)
12578                                                        {
12579                                                          /* 33222222222211111111110000000000
12580                                                             10987654321098765432109876543210
12581                                                             011001x1xx0xxxxx000011xxxxxxxxxx
12582                                                             ftsmul.  */
12583                                                          return 1479;
12584                                                        }
12585                                                      else
12586                                                        {
12587                                                          /* 33222222222211111111110000000000
12588                                                             10987654321098765432109876543210
12589                                                             011001x1xx0xxxxx000111xxxxxxxxxx
12590                                                             frsqrts.  */
12591                                                          return 1470;
12592                                                        }
12593                                                    }
12594                                                }
12595                                            }
12596                                          else
12597                                            {
12598                                              /* 33222222222211111111110000000000
12599                                                 10987654321098765432109876543210
12600                                                 011001x1xx1xxxxx000xxxxxxxxxxxxx
12601                                                 fmla.  */
12602                                              return 1438;
12603                                            }
12604                                        }
12605                                      else
12606                                        {
12607                                          /* 33222222222211111111110000000000
12608                                             10987654321098765432109876543210
12609                                             111001x1xxxxxxxx000xxxxxxxxxxxxx
12610                                             str.  */
12611                                          return 1941;
12612                                        }
12613                                    }
12614                                }
12615                              else
12616                                {
12617                                  if (((word >> 21) & 0x1) == 0)
12618                                    {
12619                                      if (((word >> 30) & 0x1) == 0)
12620                                        {
12621                                          if (((word >> 31) & 0x1) == 0)
12622                                            {
12623                                              if (((word >> 4) & 0x1) == 0)
12624                                                {
12625                                                  /* 33222222222211111111110000000000
12626                                                     10987654321098765432109876543210
12627                                                     001001x1xx0xxxxx001xxxxxxxx0xxxx
12628                                                     cmplt.  */
12629                                                  return 1339;
12630                                                }
12631                                              else
12632                                                {
12633                                                  /* 33222222222211111111110000000000
12634                                                     10987654321098765432109876543210
12635                                                     001001x1xx0xxxxx001xxxxxxxx1xxxx
12636                                                     cmple.  */
12637                                                  return 1333;
12638                                                }
12639                                            }
12640                                          else
12641                                            {
12642                                              if (((word >> 23) & 0x1) == 0)
12643                                                {
12644                                                  /* 33222222222211111111110000000000
12645                                                     10987654321098765432109876543210
12646                                                     101001x10x0xxxxx001xxxxxxxxxxxxx
12647                                                     ld1rqw.  */
12648                                                  return 1548;
12649                                                }
12650                                              else
12651                                                {
12652                                                  /* 33222222222211111111110000000000
12653                                                     10987654321098765432109876543210
12654                                                     101001x11x0xxxxx001xxxxxxxxxxxxx
12655                                                     ld1rqd.  */
12656                                                  return 1544;
12657                                                }
12658                                            }
12659                                        }
12660                                      else
12661                                        {
12662                                          if (((word >> 31) & 0x1) == 0)
12663                                            {
12664                                              if (((word >> 16) & 0x1) == 0)
12665                                                {
12666                                                  if (((word >> 17) & 0x1) == 0)
12667                                                    {
12668                                                      if (((word >> 18) & 0x1) == 0)
12669                                                        {
12670                                                          if (((word >> 19) & 0x1) == 0)
12671                                                            {
12672                                                              if (((word >> 20) & 0x1) == 0)
12673                                                                {
12674                                                                  /* 33222222222211111111110000000000
12675                                                                     10987654321098765432109876543210
12676                                                                     011001x1xx000000001xxxxxxxxxxxxx
12677                                                                     faddv.  */
12678                                                                  return 1384;
12679                                                                }
12680                                                              else
12681                                                                {
12682                                                                  if (((word >> 4) & 0x1) == 0)
12683                                                                    {
12684                                                                      /* 33222222222211111111110000000000
12685                                                                         10987654321098765432109876543210
12686                                                                         011001x1xx010000001xxxxxxxx0xxxx
12687                                                                         fcmge.  */
12688                                                                      return 1391;
12689                                                                    }
12690                                                                  else
12691                                                                    {
12692                                                                      /* 33222222222211111111110000000000
12693                                                                         10987654321098765432109876543210
12694                                                                         011001x1xx010000001xxxxxxxx1xxxx
12695                                                                         fcmgt.  */
12696                                                                      return 1393;
12697                                                                    }
12698                                                                }
12699                                                            }
12700                                                          else
12701                                                            {
12702                                                              /* 33222222222211111111110000000000
12703                                                                 10987654321098765432109876543210
12704                                                                 011001x1xx0x1000001xxxxxxxxxxxxx
12705                                                                 fadda.  */
12706                                                              return 1383;
12707                                                            }
12708                                                        }
12709                                                      else
12710                                                        {
12711                                                          /* 33222222222211111111110000000000
12712                                                             10987654321098765432109876543210
12713                                                             011001x1xx0xx100001xxxxxxxxxxxxx
12714                                                             fmaxnmv.  */
12715                                                          return 1430;
12716                                                        }
12717                                                    }
12718                                                  else
12719                                                    {
12720                                                      if (((word >> 18) & 0x1) == 0)
12721                                                        {
12722                                                          /* 33222222222211111111110000000000
12723                                                             10987654321098765432109876543210
12724                                                             011001x1xx0xx010001xxxxxxxxxxxxx
12725                                                             fcmeq.  */
12726                                                          return 1389;
12727                                                        }
12728                                                      else
12729                                                        {
12730                                                          if (((word >> 19) & 0x1) == 0)
12731                                                            {
12732                                                              /* 33222222222211111111110000000000
12733                                                                 10987654321098765432109876543210
12734                                                                 011001x1xx0x0110001xxxxxxxxxxxxx
12735                                                                 fmaxv.  */
12736                                                              return 1431;
12737                                                            }
12738                                                          else
12739                                                            {
12740                                                              /* 33222222222211111111110000000000
12741                                                                 10987654321098765432109876543210
12742                                                                 011001x1xx0x1110001xxxxxxxxxxxxx
12743                                                                 frecpe.  */
12744                                                              return 1459;
12745                                                            }
12746                                                        }
12747                                                    }
12748                                                }
12749                                              else
12750                                                {
12751                                                  if (((word >> 17) & 0x1) == 0)
12752                                                    {
12753                                                      if (((word >> 18) & 0x1) == 0)
12754                                                        {
12755                                                          if (((word >> 4) & 0x1) == 0)
12756                                                            {
12757                                                              /* 33222222222211111111110000000000
12758                                                                 10987654321098765432109876543210
12759                                                                 011001x1xx0xx001001xxxxxxxx0xxxx
12760                                                                 fcmlt.  */
12761                                                              return 1396;
12762                                                            }
12763                                                          else
12764                                                            {
12765                                                              /* 33222222222211111111110000000000
12766                                                                 10987654321098765432109876543210
12767                                                                 011001x1xx0xx001001xxxxxxxx1xxxx
12768                                                                 fcmle.  */
12769                                                              return 1395;
12770                                                            }
12771                                                        }
12772                                                      else
12773                                                        {
12774                                                          /* 33222222222211111111110000000000
12775                                                             10987654321098765432109876543210
12776                                                             011001x1xx0xx101001xxxxxxxxxxxxx
12777                                                             fminnmv.  */
12778                                                          return 1436;
12779                                                        }
12780                                                    }
12781                                                  else
12782                                                    {
12783                                                      if (((word >> 18) & 0x1) == 0)
12784                                                        {
12785                                                          /* 33222222222211111111110000000000
12786                                                             10987654321098765432109876543210
12787                                                             011001x1xx0xx011001xxxxxxxxxxxxx
12788                                                             fcmne.  */
12789                                                          return 1397;
12790                                                        }
12791                                                      else
12792                                                        {
12793                                                          if (((word >> 19) & 0x1) == 0)
12794                                                            {
12795                                                              /* 33222222222211111111110000000000
12796                                                                 10987654321098765432109876543210
12797                                                                 011001x1xx0x0111001xxxxxxxxxxxxx
12798                                                                 fminv.  */
12799                                                              return 1437;
12800                                                            }
12801                                                          else
12802                                                            {
12803                                                              /* 33222222222211111111110000000000
12804                                                                 10987654321098765432109876543210
12805                                                                 011001x1xx0x1111001xxxxxxxxxxxxx
12806                                                                 frsqrte.  */
12807                                                              return 1469;
12808                                                            }
12809                                                        }
12810                                                    }
12811                                                }
12812                                            }
12813                                          else
12814                                            {
12815                                              if (((word >> 22) & 0x1) == 0)
12816                                                {
12817                                                  if (((word >> 23) & 0x1) == 0)
12818                                                    {
12819                                                      /* 33222222222211111111110000000000
12820                                                         10987654321098765432109876543210
12821                                                         111001x1000xxxxx001xxxxxxxxxxxxx
12822                                                         stnt1w.  */
12823                                                      return 2245;
12824                                                    }
12825                                                  else
12826                                                    {
12827                                                      /* 33222222222211111111110000000000
12828                                                         10987654321098765432109876543210
12829                                                         111001x1100xxxxx001xxxxxxxxxxxxx
12830                                                         stnt1d.  */
12831                                                      return 2241;
12832                                                    }
12833                                                }
12834                                              else
12835                                                {
12836                                                  /* 33222222222211111111110000000000
12837                                                     10987654321098765432109876543210
12838                                                     111001x1x10xxxxx001xxxxxxxxxxxxx
12839                                                     stnt1w.  */
12840                                                  return 2244;
12841                                                }
12842                                            }
12843                                        }
12844                                    }
12845                                  else
12846                                    {
12847                                      if (((word >> 30) & 0x1) == 0)
12848                                        {
12849                                          if (((word >> 31) & 0x1) == 0)
12850                                            {
12851                                              if (((word >> 4) & 0x1) == 0)
12852                                                {
12853                                                  if (((word >> 12) & 0x1) == 0)
12854                                                    {
12855                                                      /* 33222222222211111111110000000000
12856                                                         10987654321098765432109876543210
12857                                                         001001x1xx1xxxxx0010xxxxxxx0xxxx
12858                                                         ctermeq.  */
12859                                                      return 1354;
12860                                                    }
12861                                                  else
12862                                                    {
12863                                                      /* 33222222222211111111110000000000
12864                                                         10987654321098765432109876543210
12865                                                         001001x1xx1xxxxx0011xxxxxxx0xxxx
12866                                                         whilewr.  */
12867                                                      return 2323;
12868                                                    }
12869                                                }
12870                                              else
12871                                                {
12872                                                  if (((word >> 12) & 0x1) == 0)
12873                                                    {
12874                                                      /* 33222222222211111111110000000000
12875                                                         10987654321098765432109876543210
12876                                                         001001x1xx1xxxxx0010xxxxxxx1xxxx
12877                                                         ctermne.  */
12878                                                      return 1355;
12879                                                    }
12880                                                  else
12881                                                    {
12882                                                      /* 33222222222211111111110000000000
12883                                                         10987654321098765432109876543210
12884                                                         001001x1xx1xxxxx0011xxxxxxx1xxxx
12885                                                         whilerw.  */
12886                                                      return 2322;
12887                                                    }
12888                                                }
12889                                            }
12890                                          else
12891                                            {
12892                                              if (((word >> 23) & 0x1) == 0)
12893                                                {
12894                                                  /* 33222222222211111111110000000000
12895                                                     10987654321098765432109876543210
12896                                                     101001x10x1xxxxx001xxxxxxxxxxxxx
12897                                                     ld1row.  */
12898                                                  return 2405;
12899                                                }
12900                                              else
12901                                                {
12902                                                  /* 33222222222211111111110000000000
12903                                                     10987654321098765432109876543210
12904                                                     101001x11x1xxxxx001xxxxxxxxxxxxx
12905                                                     ld1rod.  */
12906                                                  return 2406;
12907                                                }
12908                                            }
12909                                        }
12910                                      else
12911                                        {
12912                                          /* 33222222222211111111110000000000
12913                                             10987654321098765432109876543210
12914                                             x11001x1xx1xxxxx001xxxxxxxxxxxxx
12915                                             fmls.  */
12916                                          return 1442;
12917                                        }
12918                                    }
12919                                }
12920                            }
12921                          else
12922                            {
12923                              if (((word >> 30) & 0x1) == 0)
12924                                {
12925                                  if (((word >> 21) & 0x1) == 0)
12926                                    {
12927                                      if (((word >> 22) & 0x1) == 0)
12928                                        {
12929                                          if (((word >> 23) & 0x1) == 0)
12930                                            {
12931                                              if (((word >> 31) & 0x1) == 0)
12932                                                {
12933                                                  if (((word >> 9) & 0x1) == 0)
12934                                                    {
12935                                                      if (((word >> 20) & 0x1) == 0)
12936                                                        {
12937                                                          if (((word >> 4) & 0x1) == 0)
12938                                                            {
12939                                                              /* 33222222222211111111110000000000
12940                                                                 10987654321098765432109876543210
12941                                                                 001001x10000xxxx01xxxx0xxxx0xxxx
12942                                                                 and.  */
12943                                                              return 1285;
12944                                                            }
12945                                                          else
12946                                                            {
12947                                                              /* 33222222222211111111110000000000
12948                                                                 10987654321098765432109876543210
12949                                                                 001001x10000xxxx01xxxx0xxxx1xxxx
12950                                                                 bic.  */
12951                                                              return 1297;
12952                                                            }
12953                                                        }
12954                                                      else
12955                                                        {
12956                                                          if (((word >> 19) & 0x1) == 0)
12957                                                            {
12958                                                              /* 33222222222211111111110000000000
12959                                                                 10987654321098765432109876543210
12960                                                                 001001x100010xxx01xxxx0xxxxxxxxx
12961                                                                 brka.  */
12962                                                              return 1299;
12963                                                            }
12964                                                          else
12965                                                            {
12966                                                              /* 33222222222211111111110000000000
12967                                                                 10987654321098765432109876543210
12968                                                                 001001x100011xxx01xxxx0xxxxxxxxx
12969                                                                 brkn.  */
12970                                                              return 1303;
12971                                                            }
12972                                                        }
12973                                                    }
12974                                                  else
12975                                                    {
12976                                                      if (((word >> 4) & 0x1) == 0)
12977                                                        {
12978                                                          /* 33222222222211111111110000000000
12979                                                             10987654321098765432109876543210
12980                                                             001001x1000xxxxx01xxxx1xxxx0xxxx
12981                                                             eor.  */
12982                                                          return 1372;
12983                                                        }
12984                                                      else
12985                                                        {
12986                                                          /* 33222222222211111111110000000000
12987                                                             10987654321098765432109876543210
12988                                                             001001x1000xxxxx01xxxx1xxxx1xxxx
12989                                                             sel.  */
12990                                                          return 1821;
12991                                                        }
12992                                                    }
12993                                                }
12994                                              else
12995                                                {
12996                                                  if (((word >> 13) & 0x1) == 0)
12997                                                    {
12998                                                      /* 33222222222211111111110000000000
12999                                                         10987654321098765432109876543210
13000                                                         101001x1000xxxxx010xxxxxxxxxxxxx
13001                                                         ld1sh.  */
13002                                                      return 1571;
13003                                                    }
13004                                                  else
13005                                                    {
13006                                                      /* 33222222222211111111110000000000
13007                                                         10987654321098765432109876543210
13008                                                         101001x1000xxxxx011xxxxxxxxxxxxx
13009                                                         ldff1sh.  */
13010                                                      return 1671;
13011                                                    }
13012                                                }
13013                                            }
13014                                          else
13015                                            {
13016                                              if (((word >> 31) & 0x1) == 0)
13017                                                {
13018                                                  if (((word >> 9) & 0x1) == 0)
13019                                                    {
13020                                                      if (((word >> 20) & 0x1) == 0)
13021                                                        {
13022                                                          if (((word >> 4) & 0x1) == 0)
13023                                                            {
13024                                                              /* 33222222222211111111110000000000
13025                                                                 10987654321098765432109876543210
13026                                                                 001001x11000xxxx01xxxx0xxxx0xxxx
13027                                                                 orr.  */
13028                                                              return 1757;
13029                                                            }
13030                                                          else
13031                                                            {
13032                                                              /* 33222222222211111111110000000000
13033                                                                 10987654321098765432109876543210
13034                                                                 001001x11000xxxx01xxxx0xxxx1xxxx
13035                                                                 orn.  */
13036                                                              return 1752;
13037                                                            }
13038                                                        }
13039                                                      else
13040                                                        {
13041                                                          /* 33222222222211111111110000000000
13042                                                             10987654321098765432109876543210
13043                                                             001001x11001xxxx01xxxx0xxxxxxxxx
13044                                                             brkb.  */
13045                                                          return 1301;
13046                                                        }
13047                                                    }
13048                                                  else
13049                                                    {
13050                                                      if (((word >> 4) & 0x1) == 0)
13051                                                        {
13052                                                          /* 33222222222211111111110000000000
13053                                                             10987654321098765432109876543210
13054                                                             001001x1100xxxxx01xxxx1xxxx0xxxx
13055                                                             nor.  */
13056                                                          return 1749;
13057                                                        }
13058                                                      else
13059                                                        {
13060                                                          /* 33222222222211111111110000000000
13061                                                             10987654321098765432109876543210
13062                                                             001001x1100xxxxx01xxxx1xxxx1xxxx
13063                                                             nand.  */
13064                                                          return 1746;
13065                                                        }
13066                                                    }
13067                                                }
13068                                              else
13069                                                {
13070                                                  if (((word >> 13) & 0x1) == 0)
13071                                                    {
13072                                                      /* 33222222222211111111110000000000
13073                                                         10987654321098765432109876543210
13074                                                         101001x1100xxxxx010xxxxxxxxxxxxx
13075                                                         ld1sb.  */
13076                                                      return 1559;
13077                                                    }
13078                                                  else
13079                                                    {
13080                                                      /* 33222222222211111111110000000000
13081                                                         10987654321098765432109876543210
13082                                                         101001x1100xxxxx011xxxxxxxxxxxxx
13083                                                         ldff1sb.  */
13084                                                      return 1659;
13085                                                    }
13086                                                }
13087                                            }
13088                                        }
13089                                      else
13090                                        {
13091                                          if (((word >> 23) & 0x1) == 0)
13092                                            {
13093                                              if (((word >> 31) & 0x1) == 0)
13094                                                {
13095                                                  if (((word >> 4) & 0x1) == 0)
13096                                                    {
13097                                                      if (((word >> 9) & 0x1) == 0)
13098                                                        {
13099                                                          if (((word >> 20) & 0x1) == 0)
13100                                                            {
13101                                                              /* 33222222222211111111110000000000
13102                                                                 10987654321098765432109876543210
13103                                                                 001001x10100xxxx01xxxx0xxxx0xxxx
13104                                                                 ands.  */
13105                                                              return 1286;
13106                                                            }
13107                                                          else
13108                                                            {
13109                                                              if (((word >> 19) & 0x1) == 0)
13110                                                                {
13111                                                                  /* 33222222222211111111110000000000
13112                                                                     10987654321098765432109876543210
13113                                                                     001001x101010xxx01xxxx0xxxx0xxxx
13114                                                                     brkas.  */
13115                                                                  return 1300;
13116                                                                }
13117                                                              else
13118                                                                {
13119                                                                  /* 33222222222211111111110000000000
13120                                                                     10987654321098765432109876543210
13121                                                                     001001x101011xxx01xxxx0xxxx0xxxx
13122                                                                     brkns.  */
13123                                                                  return 1304;
13124                                                                }
13125                                                            }
13126                                                        }
13127                                                      else
13128                                                        {
13129                                                          /* 33222222222211111111110000000000
13130                                                             10987654321098765432109876543210
13131                                                             001001x1010xxxxx01xxxx1xxxx0xxxx
13132                                                             eors.  */
13133                                                          return 1373;
13134                                                        }
13135                                                    }
13136                                                  else
13137                                                    {
13138                                                      /* 33222222222211111111110000000000
13139                                                         10987654321098765432109876543210
13140                                                         001001x1010xxxxx01xxxxxxxxx1xxxx
13141                                                         bics.  */
13142                                                      return 1298;
13143                                                    }
13144                                                }
13145                                              else
13146                                                {
13147                                                  if (((word >> 13) & 0x1) == 0)
13148                                                    {
13149                                                      /* 33222222222211111111110000000000
13150                                                         10987654321098765432109876543210
13151                                                         101001x1010xxxxx010xxxxxxxxxxxxx
13152                                                         ld1w.  */
13153                                                      return 1590;
13154                                                    }
13155                                                  else
13156                                                    {
13157                                                      /* 33222222222211111111110000000000
13158                                                         10987654321098765432109876543210
13159                                                         101001x1010xxxxx011xxxxxxxxxxxxx
13160                                                         ldff1w.  */
13161                                                      return 1690;
13162                                                    }
13163                                                }
13164                                            }
13165                                          else
13166                                            {
13167                                              if (((word >> 31) & 0x1) == 0)
13168                                                {
13169                                                  if (((word >> 4) & 0x1) == 0)
13170                                                    {
13171                                                      if (((word >> 9) & 0x1) == 0)
13172                                                        {
13173                                                          if (((word >> 20) & 0x1) == 0)
13174                                                            {
13175                                                              /* 33222222222211111111110000000000
13176                                                                 10987654321098765432109876543210
13177                                                                 001001x11100xxxx01xxxx0xxxx0xxxx
13178                                                                 orrs.  */
13179                                                              return 1758;
13180                                                            }
13181                                                          else
13182                                                            {
13183                                                              /* 33222222222211111111110000000000
13184                                                                 10987654321098765432109876543210
13185                                                                 001001x11101xxxx01xxxx0xxxx0xxxx
13186                                                                 brkbs.  */
13187                                                              return 1302;
13188                                                            }
13189                                                        }
13190                                                      else
13191                                                        {
13192                                                          /* 33222222222211111111110000000000
13193                                                             10987654321098765432109876543210
13194                                                             001001x1110xxxxx01xxxx1xxxx0xxxx
13195                                                             nors.  */
13196                                                          return 1750;
13197                                                        }
13198                                                    }
13199                                                  else
13200                                                    {
13201                                                      if (((word >> 9) & 0x1) == 0)
13202                                                        {
13203                                                          /* 33222222222211111111110000000000
13204                                                             10987654321098765432109876543210
13205                                                             001001x1110xxxxx01xxxx0xxxx1xxxx
13206                                                             orns.  */
13207                                                          return 1753;
13208                                                        }
13209                                                      else
13210                                                        {
13211                                                          /* 33222222222211111111110000000000
13212                                                             10987654321098765432109876543210
13213                                                             001001x1110xxxxx01xxxx1xxxx1xxxx
13214                                                             nands.  */
13215                                                          return 1747;
13216                                                        }
13217                                                    }
13218                                                }
13219                                              else
13220                                                {
13221                                                  if (((word >> 13) & 0x1) == 0)
13222                                                    {
13223                                                      /* 33222222222211111111110000000000
13224                                                         10987654321098765432109876543210
13225                                                         101001x1110xxxxx010xxxxxxxxxxxxx
13226                                                         ld1sb.  */
13227                                                      return 1561;
13228                                                    }
13229                                                  else
13230                                                    {
13231                                                      /* 33222222222211111111110000000000
13232                                                         10987654321098765432109876543210
13233                                                         101001x1110xxxxx011xxxxxxxxxxxxx
13234                                                         ldff1sb.  */
13235                                                      return 1663;
13236                                                    }
13237                                                }
13238                                            }
13239                                        }
13240                                    }
13241                                  else
13242                                    {
13243                                      if (((word >> 13) & 0x1) == 0)
13244                                        {
13245                                          if (((word >> 22) & 0x1) == 0)
13246                                            {
13247                                              if (((word >> 23) & 0x1) == 0)
13248                                                {
13249                                                  /* 33222222222211111111110000000000
13250                                                     10987654321098765432109876543210
13251                                                     x01001x1001xxxxx010xxxxxxxxxxxxx
13252                                                     ld1sh.  */
13253                                                  return 1572;
13254                                                }
13255                                              else
13256                                                {
13257                                                  /* 33222222222211111111110000000000
13258                                                     10987654321098765432109876543210
13259                                                     x01001x1101xxxxx010xxxxxxxxxxxxx
13260                                                     ld1sb.  */
13261                                                  return 1560;
13262                                                }
13263                                            }
13264                                          else
13265                                            {
13266                                              if (((word >> 23) & 0x1) == 0)
13267                                                {
13268                                                  /* 33222222222211111111110000000000
13269                                                     10987654321098765432109876543210
13270                                                     x01001x1011xxxxx010xxxxxxxxxxxxx
13271                                                     ld1w.  */
13272                                                  return 1591;
13273                                                }
13274                                              else
13275                                                {
13276                                                  /* 33222222222211111111110000000000
13277                                                     10987654321098765432109876543210
13278                                                     x01001x1111xxxxx010xxxxxxxxxxxxx
13279                                                     ld1d.  */
13280                                                  return 1513;
13281                                                }
13282                                            }
13283                                        }
13284                                      else
13285                                        {
13286                                          if (((word >> 22) & 0x1) == 0)
13287                                            {
13288                                              if (((word >> 23) & 0x1) == 0)
13289                                                {
13290                                                  /* 33222222222211111111110000000000
13291                                                     10987654321098765432109876543210
13292                                                     x01001x1001xxxxx011xxxxxxxxxxxxx
13293                                                     ldff1sh.  */
13294                                                  return 1673;
13295                                                }
13296                                              else
13297                                                {
13298                                                  /* 33222222222211111111110000000000
13299                                                     10987654321098765432109876543210
13300                                                     x01001x1101xxxxx011xxxxxxxxxxxxx
13301                                                     ldff1sb.  */
13302                                                  return 1661;
13303                                                }
13304                                            }
13305                                          else
13306                                            {
13307                                              if (((word >> 23) & 0x1) == 0)
13308                                                {
13309                                                  /* 33222222222211111111110000000000
13310                                                     10987654321098765432109876543210
13311                                                     x01001x1011xxxxx011xxxxxxxxxxxxx
13312                                                     ldff1w.  */
13313                                                  return 1692;
13314                                                }
13315                                              else
13316                                                {
13317                                                  /* 33222222222211111111110000000000
13318                                                     10987654321098765432109876543210
13319                                                     x01001x1111xxxxx011xxxxxxxxxxxxx
13320                                                     ldff1d.  */
13321                                                  return 1637;
13322                                                }
13323                                            }
13324                                        }
13325                                    }
13326                                }
13327                              else
13328                                {
13329                                  if (((word >> 13) & 0x1) == 0)
13330                                    {
13331                                      if (((word >> 31) & 0x1) == 0)
13332                                        {
13333                                          if (((word >> 21) & 0x1) == 0)
13334                                            {
13335                                              if (((word >> 4) & 0x1) == 0)
13336                                                {
13337                                                  /* 33222222222211111111110000000000
13338                                                     10987654321098765432109876543210
13339                                                     011001x1xx0xxxxx010xxxxxxxx0xxxx
13340                                                     fcmge.  */
13341                                                  return 1392;
13342                                                }
13343                                              else
13344                                                {
13345                                                  /* 33222222222211111111110000000000
13346                                                     10987654321098765432109876543210
13347                                                     011001x1xx0xxxxx010xxxxxxxx1xxxx
13348                                                     fcmgt.  */
13349                                                  return 1394;
13350                                                }
13351                                            }
13352                                          else
13353                                            {
13354                                              /* 33222222222211111111110000000000
13355                                                 10987654321098765432109876543210
13356                                                 011001x1xx1xxxxx010xxxxxxxxxxxxx
13357                                                 fnmla.  */
13358                                              return 1456;
13359                                            }
13360                                        }
13361                                      else
13362                                        {
13363                                          if (((word >> 22) & 0x1) == 0)
13364                                            {
13365                                              /* 33222222222211111111110000000000
13366                                                 10987654321098765432109876543210
13367                                                 111001x1x0xxxxxx010xxxxxxxxxxxxx
13368                                                 str.  */
13369                                              return 1942;
13370                                            }
13371                                          else
13372                                            {
13373                                              if (((word >> 21) & 0x1) == 0)
13374                                                {
13375                                                  /* 33222222222211111111110000000000
13376                                                     10987654321098765432109876543210
13377                                                     111001x1x10xxxxx010xxxxxxxxxxxxx
13378                                                     st1w.  */
13379                                                  return 1901;
13380                                                }
13381                                              else
13382                                                {
13383                                                  if (((word >> 23) & 0x1) == 0)
13384                                                    {
13385                                                      /* 33222222222211111111110000000000
13386                                                         10987654321098765432109876543210
13387                                                         111001x1011xxxxx010xxxxxxxxxxxxx
13388                                                         st1w.  */
13389                                                      return 1903;
13390                                                    }
13391                                                  else
13392                                                    {
13393                                                      /* 33222222222211111111110000000000
13394                                                         10987654321098765432109876543210
13395                                                         111001x1111xxxxx010xxxxxxxxxxxxx
13396                                                         st1d.  */
13397                                                      return 1880;
13398                                                    }
13399                                                }
13400                                            }
13401                                        }
13402                                    }
13403                                  else
13404                                    {
13405                                      if (((word >> 21) & 0x1) == 0)
13406                                        {
13407                                          if (((word >> 31) & 0x1) == 0)
13408                                            {
13409                                              if (((word >> 4) & 0x1) == 0)
13410                                                {
13411                                                  /* 33222222222211111111110000000000
13412                                                     10987654321098765432109876543210
13413                                                     011001x1xx0xxxxx011xxxxxxxx0xxxx
13414                                                     fcmeq.  */
13415                                                  return 1390;
13416                                                }
13417                                              else
13418                                                {
13419                                                  /* 33222222222211111111110000000000
13420                                                     10987654321098765432109876543210
13421                                                     011001x1xx0xxxxx011xxxxxxxx1xxxx
13422                                                     fcmne.  */
13423                                                  return 1398;
13424                                                }
13425                                            }
13426                                          else
13427                                            {
13428                                              if (((word >> 22) & 0x1) == 0)
13429                                                {
13430                                                  if (((word >> 23) & 0x1) == 0)
13431                                                    {
13432                                                      /* 33222222222211111111110000000000
13433                                                         10987654321098765432109876543210
13434                                                         111001x1000xxxxx011xxxxxxxxxxxxx
13435                                                         stnt1w.  */
13436                                                      return 1939;
13437                                                    }
13438                                                  else
13439                                                    {
13440                                                      /* 33222222222211111111110000000000
13441                                                         10987654321098765432109876543210
13442                                                         111001x1100xxxxx011xxxxxxxxxxxxx
13443                                                         stnt1d.  */
13444                                                      return 1935;
13445                                                    }
13446                                                }
13447                                              else
13448                                                {
13449                                                  if (((word >> 23) & 0x1) == 0)
13450                                                    {
13451                                                      /* 33222222222211111111110000000000
13452                                                         10987654321098765432109876543210
13453                                                         111001x1010xxxxx011xxxxxxxxxxxxx
13454                                                         st3w.  */
13455                                                      return 1923;
13456                                                    }
13457                                                  else
13458                                                    {
13459                                                      /* 33222222222211111111110000000000
13460                                                         10987654321098765432109876543210
13461                                                         111001x1110xxxxx011xxxxxxxxxxxxx
13462                                                         st3d.  */
13463                                                      return 1919;
13464                                                    }
13465                                                }
13466                                            }
13467                                        }
13468                                      else
13469                                        {
13470                                          if (((word >> 31) & 0x1) == 0)
13471                                            {
13472                                              /* 33222222222211111111110000000000
13473                                                 10987654321098765432109876543210
13474                                                 011001x1xx1xxxxx011xxxxxxxxxxxxx
13475                                                 fnmls.  */
13476                                              return 1457;
13477                                            }
13478                                          else
13479                                            {
13480                                              if (((word >> 22) & 0x1) == 0)
13481                                                {
13482                                                  if (((word >> 23) & 0x1) == 0)
13483                                                    {
13484                                                      /* 33222222222211111111110000000000
13485                                                         10987654321098765432109876543210
13486                                                         111001x1001xxxxx011xxxxxxxxxxxxx
13487                                                         st2w.  */
13488                                                      return 1915;
13489                                                    }
13490                                                  else
13491                                                    {
13492                                                      /* 33222222222211111111110000000000
13493                                                         10987654321098765432109876543210
13494                                                         111001x1101xxxxx011xxxxxxxxxxxxx
13495                                                         st2d.  */
13496                                                      return 1911;
13497                                                    }
13498                                                }
13499                                              else
13500                                                {
13501                                                  if (((word >> 23) & 0x1) == 0)
13502                                                    {
13503                                                      /* 33222222222211111111110000000000
13504                                                         10987654321098765432109876543210
13505                                                         111001x1011xxxxx011xxxxxxxxxxxxx
13506                                                         st4w.  */
13507                                                      return 1931;
13508                                                    }
13509                                                  else
13510                                                    {
13511                                                      /* 33222222222211111111110000000000
13512                                                         10987654321098765432109876543210
13513                                                         111001x1111xxxxx011xxxxxxxxxxxxx
13514                                                         st4d.  */
13515                                                      return 1927;
13516                                                    }
13517                                                }
13518                                            }
13519                                        }
13520                                    }
13521                                }
13522                            }
13523                        }
13524                      else
13525                        {
13526                          if (((word >> 21) & 0x1) == 0)
13527                            {
13528                              if (((word >> 30) & 0x1) == 0)
13529                                {
13530                                  if (((word >> 14) & 0x1) == 0)
13531                                    {
13532                                      if (((word >> 13) & 0x1) == 0)
13533                                        {
13534                                          if (((word >> 4) & 0x1) == 0)
13535                                            {
13536                                              /* 33222222222211111111110000000000
13537                                                 10987654321098765432109876543210
13538                                                 x01001x1xx0xxxxx100xxxxxxxx0xxxx
13539                                                 cmpeq.  */
13540                                              return 1319;
13541                                            }
13542                                          else
13543                                            {
13544                                              /* 33222222222211111111110000000000
13545                                                 10987654321098765432109876543210
13546                                                 x01001x1xx0xxxxx100xxxxxxxx1xxxx
13547                                                 cmpne.  */
13548                                              return 1342;
13549                                            }
13550                                        }
13551                                      else
13552                                        {
13553                                          if (((word >> 20) & 0x1) == 0)
13554                                            {
13555                                              if (((word >> 22) & 0x1) == 0)
13556                                                {
13557                                                  if (((word >> 23) & 0x1) == 0)
13558                                                    {
13559                                                      /* 33222222222211111111110000000000
13560                                                         10987654321098765432109876543210
13561                                                         x01001x10000xxxx101xxxxxxxxxxxxx
13562                                                         ld1sh.  */
13563                                                      return 1578;
13564                                                    }
13565                                                  else
13566                                                    {
13567                                                      /* 33222222222211111111110000000000
13568                                                         10987654321098765432109876543210
13569                                                         x01001x11000xxxx101xxxxxxxxxxxxx
13570                                                         ld1sb.  */
13571                                                      return 1565;
13572                                                    }
13573                                                }
13574                                              else
13575                                                {
13576                                                  if (((word >> 23) & 0x1) == 0)
13577                                                    {
13578                                                      /* 33222222222211111111110000000000
13579                                                         10987654321098765432109876543210
13580                                                         x01001x10100xxxx101xxxxxxxxxxxxx
13581                                                         ld1w.  */
13582                                                      return 1597;
13583                                                    }
13584                                                  else
13585                                                    {
13586                                                      /* 33222222222211111111110000000000
13587                                                         10987654321098765432109876543210
13588                                                         x01001x11100xxxx101xxxxxxxxxxxxx
13589                                                         ld1sb.  */
13590                                                      return 1567;
13591                                                    }
13592                                                }
13593                                            }
13594                                          else
13595                                            {
13596                                              if (((word >> 22) & 0x1) == 0)
13597                                                {
13598                                                  if (((word >> 23) & 0x1) == 0)
13599                                                    {
13600                                                      /* 33222222222211111111110000000000
13601                                                         10987654321098765432109876543210
13602                                                         x01001x10001xxxx101xxxxxxxxxxxxx
13603                                                         ldnf1sh.  */
13604                                                      return 1711;
13605                                                    }
13606                                                  else
13607                                                    {
13608                                                      /* 33222222222211111111110000000000
13609                                                         10987654321098765432109876543210
13610                                                         x01001x11001xxxx101xxxxxxxxxxxxx
13611                                                         ldnf1sb.  */
13612                                                      return 1708;
13613                                                    }
13614                                                }
13615                                              else
13616                                                {
13617                                                  if (((word >> 23) & 0x1) == 0)
13618                                                    {
13619                                                      /* 33222222222211111111110000000000
13620                                                         10987654321098765432109876543210
13621                                                         x01001x10101xxxx101xxxxxxxxxxxxx
13622                                                         ldnf1w.  */
13623                                                      return 1714;
13624                                                    }
13625                                                  else
13626                                                    {
13627                                                      /* 33222222222211111111110000000000
13628                                                         10987654321098765432109876543210
13629                                                         x01001x11101xxxx101xxxxxxxxxxxxx
13630                                                         ldnf1sb.  */
13631                                                      return 1710;
13632                                                    }
13633                                                }
13634                                            }
13635                                        }
13636                                    }
13637                                  else
13638                                    {
13639                                      if (((word >> 31) & 0x1) == 0)
13640                                        {
13641                                          if (((word >> 4) & 0x1) == 0)
13642                                            {
13643                                              if (((word >> 20) & 0x1) == 0)
13644                                                {
13645                                                  if (((word >> 22) & 0x1) == 0)
13646                                                    {
13647                                                      /* 33222222222211111111110000000000
13648                                                         10987654321098765432109876543210
13649                                                         001001x1x000xxxx11xxxxxxxxx0xxxx
13650                                                         brkpa.  */
13651                                                      return 1305;
13652                                                    }
13653                                                  else
13654                                                    {
13655                                                      /* 33222222222211111111110000000000
13656                                                         10987654321098765432109876543210
13657                                                         001001x1x100xxxx11xxxxxxxxx0xxxx
13658                                                         brkpas.  */
13659                                                      return 1306;
13660                                                    }
13661                                                }
13662                                              else
13663                                                {
13664                                                  if (((word >> 16) & 0x1) == 0)
13665                                                    {
13666                                                      if (((word >> 19) & 0x1) == 0)
13667                                                        {
13668                                                          /* 33222222222211111111110000000000
13669                                                             10987654321098765432109876543210
13670                                                             001001x1xx010xx011xxxxxxxxx0xxxx
13671                                                             ptest.  */
13672                                                          return 1791;
13673                                                        }
13674                                                      else
13675                                                        {
13676                                                          if (((word >> 10) & 0x1) == 0)
13677                                                            {
13678                                                              if (((word >> 12) & 0x1) == 0)
13679                                                                {
13680                                                                  if (((word >> 13) & 0x1) == 0)
13681                                                                    {
13682                                                                      /* 33222222222211111111110000000000
13683                                                                         10987654321098765432109876543210
13684                                                                         001001x1xx011xx01100x0xxxxx0xxxx
13685                                                                         pfirst.  */
13686                                                                      return 1761;
13687                                                                    }
13688                                                                  else
13689                                                                    {
13690                                                                      /* 33222222222211111111110000000000
13691                                                                         10987654321098765432109876543210
13692                                                                         001001x1xx011xx01110x0xxxxx0xxxx
13693                                                                         ptrue.  */
13694                                                                      return 1792;
13695                                                                    }
13696                                                                }
13697                                                              else
13698                                                                {
13699                                                                  if (((word >> 22) & 0x1) == 0)
13700                                                                    {
13701                                                                      /* 33222222222211111111110000000000
13702                                                                         10987654321098765432109876543210
13703                                                                         001001x1x0011xx011x1x0xxxxx0xxxx
13704                                                                         rdffr.  */
13705                                                                      return 1798;
13706                                                                    }
13707                                                                  else
13708                                                                    {
13709                                                                      /* 33222222222211111111110000000000
13710                                                                         10987654321098765432109876543210
13711                                                                         001001x1x1011xx011x1x0xxxxx0xxxx
13712                                                                         rdffrs.  */
13713                                                                      return 1799;
13714                                                                    }
13715                                                                }
13716                                                            }
13717                                                          else
13718                                                            {
13719                                                              /* 33222222222211111111110000000000
13720                                                                 10987654321098765432109876543210
13721                                                                 001001x1xx011xx011xxx1xxxxx0xxxx
13722                                                                 pfalse.  */
13723                                                              return 1760;
13724                                                            }
13725                                                        }
13726                                                    }
13727                                                  else
13728                                                    {
13729                                                      if (((word >> 10) & 0x1) == 0)
13730                                                        {
13731                                                          if (((word >> 12) & 0x1) == 0)
13732                                                            {
13733                                                              /* 33222222222211111111110000000000
13734                                                                 10987654321098765432109876543210
13735                                                                 001001x1xx01xxx111x0x0xxxxx0xxxx
13736                                                                 ptrues.  */
13737                                                              return 1793;
13738                                                            }
13739                                                          else
13740                                                            {
13741                                                              /* 33222222222211111111110000000000
13742                                                                 10987654321098765432109876543210
13743                                                                 001001x1xx01xxx111x1x0xxxxx0xxxx
13744                                                                 rdffr.  */
13745                                                              return 1797;
13746                                                            }
13747                                                        }
13748                                                      else
13749                                                        {
13750                                                          /* 33222222222211111111110000000000
13751                                                             10987654321098765432109876543210
13752                                                             001001x1xx01xxx111xxx1xxxxx0xxxx
13753                                                             pnext.  */
13754                                                          return 1762;
13755                                                        }
13756                                                    }
13757                                                }
13758                                            }
13759                                          else
13760                                            {
13761                                              if (((word >> 22) & 0x1) == 0)
13762                                                {
13763                                                  /* 33222222222211111111110000000000
13764                                                     10987654321098765432109876543210
13765                                                     001001x1x00xxxxx11xxxxxxxxx1xxxx
13766                                                     brkpb.  */
13767                                                  return 1307;
13768                                                }
13769                                              else
13770                                                {
13771                                                  /* 33222222222211111111110000000000
13772                                                     10987654321098765432109876543210
13773                                                     001001x1x10xxxxx11xxxxxxxxx1xxxx
13774                                                     brkpbs.  */
13775                                                  return 1308;
13776                                                }
13777                                            }
13778                                        }
13779                                      else
13780                                        {
13781                                          if (((word >> 13) & 0x1) == 0)
13782                                            {
13783                                              if (((word >> 22) & 0x1) == 0)
13784                                                {
13785                                                  if (((word >> 23) & 0x1) == 0)
13786                                                    {
13787                                                      /* 33222222222211111111110000000000
13788                                                         10987654321098765432109876543210
13789                                                         101001x1000xxxxx110xxxxxxxxxxxxx
13790                                                         ldnt1w.  */
13791                                                      return 1722;
13792                                                    }
13793                                                  else
13794                                                    {
13795                                                      /* 33222222222211111111110000000000
13796                                                         10987654321098765432109876543210
13797                                                         101001x1100xxxxx110xxxxxxxxxxxxx
13798                                                         ldnt1d.  */
13799                                                      return 1718;
13800                                                    }
13801                                                }
13802                                              else
13803                                                {
13804                                                  if (((word >> 23) & 0x1) == 0)
13805                                                    {
13806                                                      /* 33222222222211111111110000000000
13807                                                         10987654321098765432109876543210
13808                                                         101001x1010xxxxx110xxxxxxxxxxxxx
13809                                                         ld3w.  */
13810                                                      return 1614;
13811                                                    }
13812                                                  else
13813                                                    {
13814                                                      /* 33222222222211111111110000000000
13815                                                         10987654321098765432109876543210
13816                                                         101001x1110xxxxx110xxxxxxxxxxxxx
13817                                                         ld3d.  */
13818                                                      return 1610;
13819                                                    }
13820                                                }
13821                                            }
13822                                          else
13823                                            {
13824                                              if (((word >> 22) & 0x1) == 0)
13825                                                {
13826                                                  if (((word >> 23) & 0x1) == 0)
13827                                                    {
13828                                                      /* 33222222222211111111110000000000
13829                                                         10987654321098765432109876543210
13830                                                         101001x1000xxxxx111xxxxxxxxxxxxx
13831                                                         ldnt1w.  */
13832                                                      return 1723;
13833                                                    }
13834                                                  else
13835                                                    {
13836                                                      /* 33222222222211111111110000000000
13837                                                         10987654321098765432109876543210
13838                                                         101001x1100xxxxx111xxxxxxxxxxxxx
13839                                                         ldnt1d.  */
13840                                                      return 1719;
13841                                                    }
13842                                                }
13843                                              else
13844                                                {
13845                                                  if (((word >> 23) & 0x1) == 0)
13846                                                    {
13847                                                      /* 33222222222211111111110000000000
13848                                                         10987654321098765432109876543210
13849                                                         101001x1010xxxxx111xxxxxxxxxxxxx
13850                                                         ld3w.  */
13851                                                      return 1615;
13852                                                    }
13853                                                  else
13854                                                    {
13855                                                      /* 33222222222211111111110000000000
13856                                                         10987654321098765432109876543210
13857                                                         101001x1110xxxxx111xxxxxxxxxxxxx
13858                                                         ld3d.  */
13859                                                      return 1611;
13860                                                    }
13861                                                }
13862                                            }
13863                                        }
13864                                    }
13865                                }
13866                              else
13867                                {
13868                                  if (((word >> 13) & 0x1) == 0)
13869                                    {
13870                                      if (((word >> 31) & 0x1) == 0)
13871                                        {
13872                                          if (((word >> 14) & 0x1) == 0)
13873                                            {
13874                                              if (((word >> 19) & 0x1) == 0)
13875                                                {
13876                                                  if (((word >> 20) & 0x1) == 0)
13877                                                    {
13878                                                      if (((word >> 16) & 0x1) == 0)
13879                                                        {
13880                                                          if (((word >> 17) & 0x1) == 0)
13881                                                            {
13882                                                              if (((word >> 18) & 0x1) == 0)
13883                                                                {
13884                                                                  /* 33222222222211111111110000000000
13885                                                                     10987654321098765432109876543210
13886                                                                     011001x1xx000000100xxxxxxxxxxxxx
13887                                                                     fadd.  */
13888                                                                  return 1381;
13889                                                                }
13890                                                              else
13891                                                                {
13892                                                                  /* 33222222222211111111110000000000
13893                                                                     10987654321098765432109876543210
13894                                                                     011001x1xx000100100xxxxxxxxxxxxx
13895                                                                     fmaxnm.  */
13896                                                                  return 1428;
13897                                                                }
13898                                                            }
13899                                                          else
13900                                                            {
13901                                                              if (((word >> 18) & 0x1) == 0)
13902                                                                {
13903                                                                  /* 33222222222211111111110000000000
13904                                                                     10987654321098765432109876543210
13905                                                                     011001x1xx000010100xxxxxxxxxxxxx
13906                                                                     fmul.  */
13907                                                                  return 1448;
13908                                                                }
13909                                                              else
13910                                                                {
13911                                                                  /* 33222222222211111111110000000000
13912                                                                     10987654321098765432109876543210
13913                                                                     011001x1xx000110100xxxxxxxxxxxxx
13914                                                                     fmax.  */
13915                                                                  return 1426;
13916                                                                }
13917                                                            }
13918                                                        }
13919                                                      else
13920                                                        {
13921                                                          if (((word >> 17) & 0x1) == 0)
13922                                                            {
13923                                                              if (((word >> 18) & 0x1) == 0)
13924                                                                {
13925                                                                  /* 33222222222211111111110000000000
13926                                                                     10987654321098765432109876543210
13927                                                                     011001x1xx000001100xxxxxxxxxxxxx
13928                                                                     fsub.  */
13929                                                                  return 1474;
13930                                                                }
13931                                                              else
13932                                                                {
13933                                                                  /* 33222222222211111111110000000000
13934                                                                     10987654321098765432109876543210
13935                                                                     011001x1xx000101100xxxxxxxxxxxxx
13936                                                                     fminnm.  */
13937                                                                  return 1434;
13938                                                                }
13939                                                            }
13940                                                          else
13941                                                            {
13942                                                              if (((word >> 18) & 0x1) == 0)
13943                                                                {
13944                                                                  /* 33222222222211111111110000000000
13945                                                                     10987654321098765432109876543210
13946                                                                     011001x1xx000011100xxxxxxxxxxxxx
13947                                                                     fsubr.  */
13948                                                                  return 1476;
13949                                                                }
13950                                                              else
13951                                                                {
13952                                                                  /* 33222222222211111111110000000000
13953                                                                     10987654321098765432109876543210
13954                                                                     011001x1xx000111100xxxxxxxxxxxxx
13955                                                                     fmin.  */
13956                                                                  return 1432;
13957                                                                }
13958                                                            }
13959                                                        }
13960                                                    }
13961                                                  else
13962                                                    {
13963                                                      /* 33222222222211111111110000000000
13964                                                         10987654321098765432109876543210
13965                                                         011001x1xx010xxx100xxxxxxxxxxxxx
13966                                                         ftmad.  */
13967                                                      return 1478;
13968                                                    }
13969                                                }
13970                                              else
13971                                                {
13972                                                  if (((word >> 16) & 0x1) == 0)
13973                                                    {
13974                                                      if (((word >> 17) & 0x1) == 0)
13975                                                        {
13976                                                          if (((word >> 18) & 0x1) == 0)
13977                                                            {
13978                                                              if (((word >> 20) & 0x1) == 0)
13979                                                                {
13980                                                                  /* 33222222222211111111110000000000
13981                                                                     10987654321098765432109876543210
13982                                                                     011001x1xx001000100xxxxxxxxxxxxx
13983                                                                     fabd.  */
13984                                                                  return 1376;
13985                                                                }
13986                                                              else
13987                                                                {
13988                                                                  /* 33222222222211111111110000000000
13989                                                                     10987654321098765432109876543210
13990                                                                     011001x1xx011000100xxxxxxxxxxxxx
13991                                                                     fadd.  */
13992                                                                  return 1382;
13993                                                                }
13994                                                            }
13995                                                          else
13996                                                            {
13997                                                              if (((word >> 20) & 0x1) == 0)
13998                                                                {
13999                                                                  /* 33222222222211111111110000000000
14000                                                                     10987654321098765432109876543210
14001                                                                     011001x1xx001100100xxxxxxxxxxxxx
14002                                                                     fdivr.  */
14003                                                                  return 1422;
14004                                                                }
14005                                                              else
14006                                                                {
14007                                                                  /* 33222222222211111111110000000000
14008                                                                     10987654321098765432109876543210
14009                                                                     011001x1xx011100100xxxxxxxxxxxxx
14010                                                                     fmaxnm.  */
14011                                                                  return 1429;
14012                                                                }
14013                                                            }
14014                                                        }
14015                                                      else
14016                                                        {
14017                                                          if (((word >> 18) & 0x1) == 0)
14018                                                            {
14019                                                              if (((word >> 20) & 0x1) == 0)
14020                                                                {
14021                                                                  /* 33222222222211111111110000000000
14022                                                                     10987654321098765432109876543210
14023                                                                     011001x1xx001010100xxxxxxxxxxxxx
14024                                                                     fmulx.  */
14025                                                                  return 1453;
14026                                                                }
14027                                                              else
14028                                                                {
14029                                                                  /* 33222222222211111111110000000000
14030                                                                     10987654321098765432109876543210
14031                                                                     011001x1xx011010100xxxxxxxxxxxxx
14032                                                                     fmul.  */
14033                                                                  return 1449;
14034                                                                }
14035                                                            }
14036                                                          else
14037                                                            {
14038                                                              /* 33222222222211111111110000000000
14039                                                                 10987654321098765432109876543210
14040                                                                 011001x1xx0x1110100xxxxxxxxxxxxx
14041                                                                 fmax.  */
14042                                                              return 1427;
14043                                                            }
14044                                                        }
14045                                                    }
14046                                                  else
14047                                                    {
14048                                                      if (((word >> 17) & 0x1) == 0)
14049                                                        {
14050                                                          if (((word >> 18) & 0x1) == 0)
14051                                                            {
14052                                                              if (((word >> 20) & 0x1) == 0)
14053                                                                {
14054                                                                  /* 33222222222211111111110000000000
14055                                                                     10987654321098765432109876543210
14056                                                                     011001x1xx001001100xxxxxxxxxxxxx
14057                                                                     fscale.  */
14058                                                                  return 1471;
14059                                                                }
14060                                                              else
14061                                                                {
14062                                                                  /* 33222222222211111111110000000000
14063                                                                     10987654321098765432109876543210
14064                                                                     011001x1xx011001100xxxxxxxxxxxxx
14065                                                                     fsub.  */
14066                                                                  return 1475;
14067                                                                }
14068                                                            }
14069                                                          else
14070                                                            {
14071                                                              if (((word >> 20) & 0x1) == 0)
14072                                                                {
14073                                                                  /* 33222222222211111111110000000000
14074                                                                     10987654321098765432109876543210
14075                                                                     011001x1xx001101100xxxxxxxxxxxxx
14076                                                                     fdiv.  */
14077                                                                  return 1421;
14078                                                                }
14079                                                              else
14080                                                                {
14081                                                                  /* 33222222222211111111110000000000
14082                                                                     10987654321098765432109876543210
14083                                                                     011001x1xx011101100xxxxxxxxxxxxx
14084                                                                     fminnm.  */
14085                                                                  return 1435;
14086                                                                }
14087                                                            }
14088                                                        }
14089                                                      else
14090                                                        {
14091                                                          if (((word >> 18) & 0x1) == 0)
14092                                                            {
14093                                                              /* 33222222222211111111110000000000
14094                                                                 10987654321098765432109876543210
14095                                                                 011001x1xx0x1011100xxxxxxxxxxxxx
14096                                                                 fsubr.  */
14097                                                              return 1477;
14098                                                            }
14099                                                          else
14100                                                            {
14101                                                              /* 33222222222211111111110000000000
14102                                                                 10987654321098765432109876543210
14103                                                                 011001x1xx0x1111100xxxxxxxxxxxxx
14104                                                                 fmin.  */
14105                                                              return 1433;
14106                                                            }
14107                                                        }
14108                                                    }
14109                                                }
14110                                            }
14111                                          else
14112                                            {
14113                                              if (((word >> 4) & 0x1) == 0)
14114                                                {
14115                                                  /* 33222222222211111111110000000000
14116                                                     10987654321098765432109876543210
14117                                                     011001x1xx0xxxxx110xxxxxxxx0xxxx
14118                                                     fcmuo.  */
14119                                                  return 1399;
14120                                                }
14121                                              else
14122                                                {
14123                                                  /* 33222222222211111111110000000000
14124                                                     10987654321098765432109876543210
14125                                                     011001x1xx0xxxxx110xxxxxxxx1xxxx
14126                                                     facge.  */
14127                                                  return 1378;
14128                                                }
14129                                            }
14130                                        }
14131                                      else
14132                                        {
14133                                          if (((word >> 22) & 0x1) == 0)
14134                                            {
14135                                              if (((word >> 23) & 0x1) == 0)
14136                                                {
14137                                                  /* 33222222222211111111110000000000
14138                                                     10987654321098765432109876543210
14139                                                     111001x1000xxxxx1x0xxxxxxxxxxxxx
14140                                                     st1w.  */
14141                                                  return 1897;
14142                                                }
14143                                              else
14144                                                {
14145                                                  /* 33222222222211111111110000000000
14146                                                     10987654321098765432109876543210
14147                                                     111001x1100xxxxx1x0xxxxxxxxxxxxx
14148                                                     st1d.  */
14149                                                  return 1876;
14150                                                }
14151                                            }
14152                                          else
14153                                            {
14154                                              /* 33222222222211111111110000000000
14155                                                 10987654321098765432109876543210
14156                                                 111001x1x10xxxxx1x0xxxxxxxxxxxxx
14157                                                 st1w.  */
14158                                              return 1902;
14159                                            }
14160                                        }
14161                                    }
14162                                  else
14163                                    {
14164                                      if (((word >> 14) & 0x1) == 0)
14165                                        {
14166                                          if (((word >> 31) & 0x1) == 0)
14167                                            {
14168                                              if (((word >> 16) & 0x1) == 0)
14169                                                {
14170                                                  if (((word >> 19) & 0x1) == 0)
14171                                                    {
14172                                                      if (((word >> 17) & 0x1) == 0)
14173                                                        {
14174                                                          if (((word >> 18) & 0x1) == 0)
14175                                                            {
14176                                                              if (((word >> 20) & 0x1) == 0)
14177                                                                {
14178                                                                  /* 33222222222211111111110000000000
14179                                                                     10987654321098765432109876543210
14180                                                                     011001x1xx000000101xxxxxxxxxxxxx
14181                                                                     frintn.  */
14182                                                                  return 1465;
14183                                                                }
14184                                                              else
14185                                                                {
14186                                                                  /* 33222222222211111111110000000000
14187                                                                     10987654321098765432109876543210
14188                                                                     011001x1xx010000101xxxxxxxxxxxxx
14189                                                                     scvtf.  */
14190                                                                  return 1811;
14191                                                                }
14192                                                            }
14193                                                          else
14194                                                            {
14195                                                              if (((word >> 20) & 0x1) == 0)
14196                                                                {
14197                                                                  /* 33222222222211111111110000000000
14198                                                                     10987654321098765432109876543210
14199                                                                     011001x1xx000100101xxxxxxxxxxxxx
14200                                                                     frinta.  */
14201                                                                  return 1462;
14202                                                                }
14203                                                              else
14204                                                                {
14205                                                                  if (((word >> 22) & 0x1) == 0)
14206                                                                    {
14207                                                                      /* 33222222222211111111110000000000
14208                                                                         10987654321098765432109876543210
14209                                                                         011001x1x0010100101xxxxxxxxxxxxx
14210                                                                         scvtf.  */
14211                                                                      return 1810;
14212                                                                    }
14213                                                                  else
14214                                                                    {
14215                                                                      if (((word >> 23) & 0x1) == 0)
14216                                                                        {
14217                                                                          /* 33222222222211111111110000000000
14218                                                                             10987654321098765432109876543210
14219                                                                             011001x101010100101xxxxxxxxxxxxx
14220                                                                             scvtf.  */
14221                                                                          return 1809;
14222                                                                        }
14223                                                                      else
14224                                                                        {
14225                                                                          /* 33222222222211111111110000000000
14226                                                                             10987654321098765432109876543210
14227                                                                             011001x111010100101xxxxxxxxxxxxx
14228                                                                             scvtf.  */
14229                                                                          return 1813;
14230                                                                        }
14231                                                                    }
14232                                                                }
14233                                                            }
14234                                                        }
14235                                                      else
14236                                                        {
14237                                                          if (((word >> 18) & 0x1) == 0)
14238                                                            {
14239                                                              if (((word >> 20) & 0x1) == 0)
14240                                                                {
14241                                                                  /* 33222222222211111111110000000000
14242                                                                     10987654321098765432109876543210
14243                                                                     011001x1xx000010101xxxxxxxxxxxxx
14244                                                                     frintm.  */
14245                                                                  return 1464;
14246                                                                }
14247                                                              else
14248                                                                {
14249                                                                  /* 33222222222211111111110000000000
14250                                                                     10987654321098765432109876543210
14251                                                                     011001x1xx010010101xxxxxxxxxxxxx
14252                                                                     scvtf.  */
14253                                                                  return 1808;
14254                                                                }
14255                                                            }
14256                                                          else
14257                                                            {
14258                                                              if (((word >> 20) & 0x1) == 0)
14259                                                                {
14260                                                                  /* 33222222222211111111110000000000
14261                                                                     10987654321098765432109876543210
14262                                                                     011001x1xx000110101xxxxxxxxxxxxx
14263                                                                     frintx.  */
14264                                                                  return 1467;
14265                                                                }
14266                                                              else
14267                                                                {
14268                                                                  if (((word >> 23) & 0x1) == 0)
14269                                                                    {
14270                                                                      /* 33222222222211111111110000000000
14271                                                                         10987654321098765432109876543210
14272                                                                         011001x10x010110101xxxxxxxxxxxxx
14273                                                                         scvtf.  */
14274                                                                      return 1812;
14275                                                                    }
14276                                                                  else
14277                                                                    {
14278                                                                      /* 33222222222211111111110000000000
14279                                                                         10987654321098765432109876543210
14280                                                                         011001x11x010110101xxxxxxxxxxxxx
14281                                                                         scvtf.  */
14282                                                                      return 1814;
14283                                                                    }
14284                                                                }
14285                                                            }
14286                                                        }
14287                                                    }
14288                                                  else
14289                                                    {
14290                                                      if (((word >> 20) & 0x1) == 0)
14291                                                        {
14292                                                          if (((word >> 17) & 0x1) == 0)
14293                                                            {
14294                                                              if (((word >> 18) & 0x1) == 0)
14295                                                                {
14296                                                                  if (((word >> 22) & 0x1) == 0)
14297                                                                    {
14298                                                                      /* 33222222222211111111110000000000
14299                                                                         10987654321098765432109876543210
14300                                                                         011001x1x0001000101xxxxxxxxxxxxx
14301                                                                         fcvt.  */
14302                                                                      return 1401;
14303                                                                    }
14304                                                                  else
14305                                                                    {
14306                                                                      /* 33222222222211111111110000000000
14307                                                                         10987654321098765432109876543210
14308                                                                         011001x1x1001000101xxxxxxxxxxxxx
14309                                                                         fcvt.  */
14310                                                                      return 1403;
14311                                                                    }
14312                                                                }
14313                                                              else
14314                                                                {
14315                                                                  /* 33222222222211111111110000000000
14316                                                                     10987654321098765432109876543210
14317                                                                     011001x1xx001100101xxxxxxxxxxxxx
14318                                                                     frecpx.  */
14319                                                                  return 1461;
14320                                                                }
14321                                                            }
14322                                                          else
14323                                                            {
14324                                                              if (((word >> 22) & 0x1) == 0)
14325                                                                {
14326                                                                  if (((word >> 23) & 0x1) == 0)
14327                                                                    {
14328                                                                      /* 33222222222211111111110000000000
14329                                                                         10987654321098765432109876543210
14330                                                                         011001x100001x10101xxxxxxxxxxxxx
14331                                                                         fcvtx.  */
14332                                                                      return 2071;
14333                                                                    }
14334                                                                  else
14335                                                                    {
14336                                                                      /* 33222222222211111111110000000000
14337                                                                         10987654321098765432109876543210
14338                                                                         011001x110001x10101xxxxxxxxxxxxx
14339                                                                         bfcvt.  */
14340                                                                      return 2422;
14341                                                                    }
14342                                                                }
14343                                                              else
14344                                                                {
14345                                                                  /* 33222222222211111111110000000000
14346                                                                     10987654321098765432109876543210
14347                                                                     011001x1x1001x10101xxxxxxxxxxxxx
14348                                                                     fcvt.  */
14349                                                                  return 1405;
14350                                                                }
14351                                                            }
14352                                                        }
14353                                                      else
14354                                                        {
14355                                                          if (((word >> 22) & 0x1) == 0)
14356                                                            {
14357                                                              if (((word >> 23) & 0x1) == 0)
14358                                                                {
14359                                                                  /* 33222222222211111111110000000000
14360                                                                     10987654321098765432109876543210
14361                                                                     011001x100011xx0101xxxxxxxxxxxxx
14362                                                                     flogb.  */
14363                                                                  return 2073;
14364                                                                }
14365                                                              else
14366                                                                {
14367                                                                  /* 33222222222211111111110000000000
14368                                                                     10987654321098765432109876543210
14369                                                                     011001x110011xx0101xxxxxxxxxxxxx
14370                                                                     fcvtzs.  */
14371                                                                  return 1410;
14372                                                                }
14373                                                            }
14374                                                          else
14375                                                            {
14376                                                              if (((word >> 17) & 0x1) == 0)
14377                                                                {
14378                                                                  if (((word >> 18) & 0x1) == 0)
14379                                                                    {
14380                                                                      /* 33222222222211111111110000000000
14381                                                                         10987654321098765432109876543210
14382                                                                         011001x1x1011000101xxxxxxxxxxxxx
14383                                                                         fcvtzs.  */
14384                                                                      return 1411;
14385                                                                    }
14386                                                                  else
14387                                                                    {
14388                                                                      if (((word >> 23) & 0x1) == 0)
14389                                                                        {
14390                                                                          /* 33222222222211111111110000000000
14391                                                                             10987654321098765432109876543210
14392                                                                             011001x101011100101xxxxxxxxxxxxx
14393                                                                             fcvtzs.  */
14394                                                                          return 1408;
14395                                                                        }
14396                                                                      else
14397                                                                        {
14398                                                                          /* 33222222222211111111110000000000
14399                                                                             10987654321098765432109876543210
14400                                                                             011001x111011100101xxxxxxxxxxxxx
14401                                                                             fcvtzs.  */
14402                                                                          return 1412;
14403                                                                        }
14404                                                                    }
14405                                                                }
14406                                                              else
14407                                                                {
14408                                                                  if (((word >> 18) & 0x1) == 0)
14409                                                                    {
14410                                                                      /* 33222222222211111111110000000000
14411                                                                         10987654321098765432109876543210
14412                                                                         011001x1x1011010101xxxxxxxxxxxxx
14413                                                                         fcvtzs.  */
14414                                                                      return 1407;
14415                                                                    }
14416                                                                  else
14417                                                                    {
14418                                                                      if (((word >> 23) & 0x1) == 0)
14419                                                                        {
14420                                                                          /* 33222222222211111111110000000000
14421                                                                             10987654321098765432109876543210
14422                                                                             011001x101011110101xxxxxxxxxxxxx
14423                                                                             fcvtzs.  */
14424                                                                          return 1409;
14425                                                                        }
14426                                                                      else
14427                                                                        {
14428                                                                          /* 33222222222211111111110000000000
14429                                                                             10987654321098765432109876543210
14430                                                                             011001x111011110101xxxxxxxxxxxxx
14431                                                                             fcvtzs.  */
14432                                                                          return 1413;
14433                                                                        }
14434                                                                    }
14435                                                                }
14436                                                            }
14437                                                        }
14438                                                    }
14439                                                }
14440                                              else
14441                                                {
14442                                                  if (((word >> 17) & 0x1) == 0)
14443                                                    {
14444                                                      if (((word >> 18) & 0x1) == 0)
14445                                                        {
14446                                                          if (((word >> 19) & 0x1) == 0)
14447                                                            {
14448                                                              if (((word >> 20) & 0x1) == 0)
14449                                                                {
14450                                                                  /* 33222222222211111111110000000000
14451                                                                     10987654321098765432109876543210
14452                                                                     011001x1xx000001101xxxxxxxxxxxxx
14453                                                                     frintp.  */
14454                                                                  return 1466;
14455                                                                }
14456                                                              else
14457                                                                {
14458                                                                  /* 33222222222211111111110000000000
14459                                                                     10987654321098765432109876543210
14460                                                                     011001x1xx010001101xxxxxxxxxxxxx
14461                                                                     ucvtf.  */
14462                                                                  return 1963;
14463                                                                }
14464                                                            }
14465                                                          else
14466                                                            {
14467                                                              if (((word >> 20) & 0x1) == 0)
14468                                                                {
14469                                                                  if (((word >> 22) & 0x1) == 0)
14470                                                                    {
14471                                                                      /* 33222222222211111111110000000000
14472                                                                         10987654321098765432109876543210
14473                                                                         011001x1x0001001101xxxxxxxxxxxxx
14474                                                                         fcvt.  */
14475                                                                      return 1402;
14476                                                                    }
14477                                                                  else
14478                                                                    {
14479                                                                      /* 33222222222211111111110000000000
14480                                                                         10987654321098765432109876543210
14481                                                                         011001x1x1001001101xxxxxxxxxxxxx
14482                                                                         fcvt.  */
14483                                                                      return 1404;
14484                                                                    }
14485                                                                }
14486                                                              else
14487                                                                {
14488                                                                  /* 33222222222211111111110000000000
14489                                                                     10987654321098765432109876543210
14490                                                                     011001x1xx011001101xxxxxxxxxxxxx
14491                                                                     fcvtzu.  */
14492                                                                  return 1418;
14493                                                                }
14494                                                            }
14495                                                        }
14496                                                      else
14497                                                        {
14498                                                          if (((word >> 19) & 0x1) == 0)
14499                                                            {
14500                                                              if (((word >> 22) & 0x1) == 0)
14501                                                                {
14502                                                                  /* 33222222222211111111110000000000
14503                                                                     10987654321098765432109876543210
14504                                                                     011001x1x00x0101101xxxxxxxxxxxxx
14505                                                                     ucvtf.  */
14506                                                                  return 1962;
14507                                                                }
14508                                                              else
14509                                                                {
14510                                                                  if (((word >> 23) & 0x1) == 0)
14511                                                                    {
14512                                                                      /* 33222222222211111111110000000000
14513                                                                         10987654321098765432109876543210
14514                                                                         011001x1010x0101101xxxxxxxxxxxxx
14515                                                                         ucvtf.  */
14516                                                                      return 1961;
14517                                                                    }
14518                                                                  else
14519                                                                    {
14520                                                                      /* 33222222222211111111110000000000
14521                                                                         10987654321098765432109876543210
14522                                                                         011001x1110x0101101xxxxxxxxxxxxx
14523                                                                         ucvtf.  */
14524                                                                      return 1965;
14525                                                                    }
14526                                                                }
14527                                                            }
14528                                                          else
14529                                                            {
14530                                                              if (((word >> 20) & 0x1) == 0)
14531                                                                {
14532                                                                  /* 33222222222211111111110000000000
14533                                                                     10987654321098765432109876543210
14534                                                                     011001x1xx001101101xxxxxxxxxxxxx
14535                                                                     fsqrt.  */
14536                                                                  return 1472;
14537                                                                }
14538                                                              else
14539                                                                {
14540                                                                  if (((word >> 22) & 0x1) == 0)
14541                                                                    {
14542                                                                      /* 33222222222211111111110000000000
14543                                                                         10987654321098765432109876543210
14544                                                                         011001x1x0011101101xxxxxxxxxxxxx
14545                                                                         fcvtzu.  */
14546                                                                      return 1417;
14547                                                                    }
14548                                                                  else
14549                                                                    {
14550                                                                      if (((word >> 23) & 0x1) == 0)
14551                                                                        {
14552                                                                          /* 33222222222211111111110000000000
14553                                                                             10987654321098765432109876543210
14554                                                                             011001x101011101101xxxxxxxxxxxxx
14555                                                                             fcvtzu.  */
14556                                                                          return 1415;
14557                                                                        }
14558                                                                      else
14559                                                                        {
14560                                                                          /* 33222222222211111111110000000000
14561                                                                             10987654321098765432109876543210
14562                                                                             011001x111011101101xxxxxxxxxxxxx
14563                                                                             fcvtzu.  */
14564                                                                          return 1419;
14565                                                                        }
14566                                                                    }
14567                                                                }
14568                                                            }
14569                                                        }
14570                                                    }
14571                                                  else
14572                                                    {
14573                                                      if (((word >> 18) & 0x1) == 0)
14574                                                        {
14575                                                          if (((word >> 19) & 0x1) == 0)
14576                                                            {
14577                                                              if (((word >> 20) & 0x1) == 0)
14578                                                                {
14579                                                                  /* 33222222222211111111110000000000
14580                                                                     10987654321098765432109876543210
14581                                                                     011001x1xx000011101xxxxxxxxxxxxx
14582                                                                     frintz.  */
14583                                                                  return 1468;
14584                                                                }
14585                                                              else
14586                                                                {
14587                                                                  /* 33222222222211111111110000000000
14588                                                                     10987654321098765432109876543210
14589                                                                     011001x1xx010011101xxxxxxxxxxxxx
14590                                                                     ucvtf.  */
14591                                                                  return 1960;
14592                                                                }
14593                                                            }
14594                                                          else
14595                                                            {
14596                                                              if (((word >> 20) & 0x1) == 0)
14597                                                                {
14598                                                                  /* 33222222222211111111110000000000
14599                                                                     10987654321098765432109876543210
14600                                                                     011001x1xx001011101xxxxxxxxxxxxx
14601                                                                     fcvt.  */
14602                                                                  return 1406;
14603                                                                }
14604                                                              else
14605                                                                {
14606                                                                  /* 33222222222211111111110000000000
14607                                                                     10987654321098765432109876543210
14608                                                                     011001x1xx011011101xxxxxxxxxxxxx
14609                                                                     fcvtzu.  */
14610                                                                  return 1414;
14611                                                                }
14612                                                            }
14613                                                        }
14614                                                      else
14615                                                        {
14616                                                          if (((word >> 19) & 0x1) == 0)
14617                                                            {
14618                                                              if (((word >> 20) & 0x1) == 0)
14619                                                                {
14620                                                                  /* 33222222222211111111110000000000
14621                                                                     10987654321098765432109876543210
14622                                                                     011001x1xx000111101xxxxxxxxxxxxx
14623                                                                     frinti.  */
14624                                                                  return 1463;
14625                                                                }
14626                                                              else
14627                                                                {
14628                                                                  if (((word >> 23) & 0x1) == 0)
14629                                                                    {
14630                                                                      /* 33222222222211111111110000000000
14631                                                                         10987654321098765432109876543210
14632                                                                         011001x10x010111101xxxxxxxxxxxxx
14633                                                                         ucvtf.  */
14634                                                                      return 1964;
14635                                                                    }
14636                                                                  else
14637                                                                    {
14638                                                                      /* 33222222222211111111110000000000
14639                                                                         10987654321098765432109876543210
14640                                                                         011001x11x010111101xxxxxxxxxxxxx
14641                                                                         ucvtf.  */
14642                                                                      return 1966;
14643                                                                    }
14644                                                                }
14645                                                            }
14646                                                          else
14647                                                            {
14648                                                              if (((word >> 23) & 0x1) == 0)
14649                                                                {
14650                                                                  /* 33222222222211111111110000000000
14651                                                                     10987654321098765432109876543210
14652                                                                     011001x10x0x1111101xxxxxxxxxxxxx
14653                                                                     fcvtzu.  */
14654                                                                  return 1416;
14655                                                                }
14656                                                              else
14657                                                                {
14658                                                                  /* 33222222222211111111110000000000
14659                                                                     10987654321098765432109876543210
14660                                                                     011001x11x0x1111101xxxxxxxxxxxxx
14661                                                                     fcvtzu.  */
14662                                                                  return 1420;
14663                                                                }
14664                                                            }
14665                                                        }
14666                                                    }
14667                                                }
14668                                            }
14669                                          else
14670                                            {
14671                                              if (((word >> 22) & 0x1) == 0)
14672                                                {
14673                                                  if (((word >> 23) & 0x1) == 0)
14674                                                    {
14675                                                      /* 33222222222211111111110000000000
14676                                                         10987654321098765432109876543210
14677                                                         111001x1000xxxxx101xxxxxxxxxxxxx
14678                                                         st1w.  */
14679                                                      return 1898;
14680                                                    }
14681                                                  else
14682                                                    {
14683                                                      /* 33222222222211111111110000000000
14684                                                         10987654321098765432109876543210
14685                                                         111001x1100xxxxx101xxxxxxxxxxxxx
14686                                                         st1d.  */
14687                                                      return 1877;
14688                                                    }
14689                                                }
14690                                              else
14691                                                {
14692                                                  if (((word >> 23) & 0x1) == 0)
14693                                                    {
14694                                                      /* 33222222222211111111110000000000
14695                                                         10987654321098765432109876543210
14696                                                         111001x1010xxxxx101xxxxxxxxxxxxx
14697                                                         st1w.  */
14698                                                      return 1905;
14699                                                    }
14700                                                  else
14701                                                    {
14702                                                      /* 33222222222211111111110000000000
14703                                                         10987654321098765432109876543210
14704                                                         111001x1110xxxxx101xxxxxxxxxxxxx
14705                                                         st1d.  */
14706                                                      return 1881;
14707                                                    }
14708                                                }
14709                                            }
14710                                        }
14711                                      else
14712                                        {
14713                                          if (((word >> 31) & 0x1) == 0)
14714                                            {
14715                                              /* 33222222222211111111110000000000
14716                                                 10987654321098765432109876543210
14717                                                 011001x1xx0xxxxx111xxxxxxxxxxxxx
14718                                                 facgt.  */
14719                                              return 1379;
14720                                            }
14721                                          else
14722                                            {
14723                                              if (((word >> 20) & 0x1) == 0)
14724                                                {
14725                                                  /* 33222222222211111111110000000000
14726                                                     10987654321098765432109876543210
14727                                                     111001x1xx00xxxx111xxxxxxxxxxxxx
14728                                                     st1w.  */
14729                                                  return 1906;
14730                                                }
14731                                              else
14732                                                {
14733                                                  if (((word >> 22) & 0x1) == 0)
14734                                                    {
14735                                                      if (((word >> 23) & 0x1) == 0)
14736                                                        {
14737                                                          /* 33222222222211111111110000000000
14738                                                             10987654321098765432109876543210
14739                                                             111001x10001xxxx111xxxxxxxxxxxxx
14740                                                             stnt1w.  */
14741                                                          return 1940;
14742                                                        }
14743                                                      else
14744                                                        {
14745                                                          /* 33222222222211111111110000000000
14746                                                             10987654321098765432109876543210
14747                                                             111001x11001xxxx111xxxxxxxxxxxxx
14748                                                             stnt1d.  */
14749                                                          return 1936;
14750                                                        }
14751                                                    }
14752                                                  else
14753                                                    {
14754                                                      if (((word >> 23) & 0x1) == 0)
14755                                                        {
14756                                                          /* 33222222222211111111110000000000
14757                                                             10987654321098765432109876543210
14758                                                             111001x10101xxxx111xxxxxxxxxxxxx
14759                                                             st3w.  */
14760                                                          return 1924;
14761                                                        }
14762                                                      else
14763                                                        {
14764                                                          /* 33222222222211111111110000000000
14765                                                             10987654321098765432109876543210
14766                                                             111001x11101xxxx111xxxxxxxxxxxxx
14767                                                             st3d.  */
14768                                                          return 1920;
14769                                                        }
14770                                                    }
14771                                                }
14772                                            }
14773                                        }
14774                                    }
14775                                }
14776                            }
14777                          else
14778                            {
14779                              if (((word >> 30) & 0x1) == 0)
14780                                {
14781                                  if (((word >> 14) & 0x1) == 0)
14782                                    {
14783                                      if (((word >> 20) & 0x1) == 0)
14784                                        {
14785                                          if (((word >> 31) & 0x1) == 0)
14786                                            {
14787                                              if (((word >> 16) & 0x1) == 0)
14788                                                {
14789                                                  if (((word >> 17) & 0x1) == 0)
14790                                                    {
14791                                                      if (((word >> 18) & 0x1) == 0)
14792                                                        {
14793                                                          if (((word >> 19) & 0x1) == 0)
14794                                                            {
14795                                                              /* 33222222222211111111110000000000
14796                                                                 10987654321098765432109876543210
14797                                                                 001001x1xx10000010xxxxxxxxxxxxxx
14798                                                                 cntp.  */
14799                                                              return 1348;
14800                                                            }
14801                                                          else
14802                                                            {
14803                                                              if (((word >> 10) & 0x1) == 0)
14804                                                                {
14805                                                                  if (((word >> 11) & 0x1) == 0)
14806                                                                    {
14807                                                                      if (((word >> 12) & 0x1) == 0)
14808                                                                        {
14809                                                                          /* 33222222222211111111110000000000
14810                                                                             10987654321098765432109876543210
14811                                                                             001001x1xx10100010x000xxxxxxxxxx
14812                                                                             sqincp.  */
14813                                                                          return 1855;
14814                                                                        }
14815                                                                      else
14816                                                                        {
14817                                                                          /* 33222222222211111111110000000000
14818                                                                             10987654321098765432109876543210
14819                                                                             001001x1xx10100010x100xxxxxxxxxx
14820                                                                             wrffr.  */
14821                                                                          return 2028;
14822                                                                        }
14823                                                                    }
14824                                                                  else
14825                                                                    {
14826                                                                      /* 33222222222211111111110000000000
14827                                                                         10987654321098765432109876543210
14828                                                                         001001x1xx10100010xx10xxxxxxxxxx
14829                                                                         sqincp.  */
14830                                                                      return 1857;
14831                                                                    }
14832                                                                }
14833                                                              else
14834                                                                {
14835                                                                  /* 33222222222211111111110000000000
14836                                                                     10987654321098765432109876543210
14837                                                                     001001x1xx10100010xxx1xxxxxxxxxx
14838                                                                     sqincp.  */
14839                                                                  return 1856;
14840                                                                }
14841                                                            }
14842                                                        }
14843                                                      else
14844                                                        {
14845                                                          if (((word >> 11) & 0x1) == 0)
14846                                                            {
14847                                                              if (((word >> 12) & 0x1) == 0)
14848                                                                {
14849                                                                  /* 33222222222211111111110000000000
14850                                                                     10987654321098765432109876543210
14851                                                                     001001x1xx10x10010x00xxxxxxxxxxx
14852                                                                     incp.  */
14853                                                                  return 1486;
14854                                                                }
14855                                                              else
14856                                                                {
14857                                                                  /* 33222222222211111111110000000000
14858                                                                     10987654321098765432109876543210
14859                                                                     001001x1xx10x10010x10xxxxxxxxxxx
14860                                                                     setffr.  */
14861                                                                  return 1822;
14862                                                                }
14863                                                            }
14864                                                          else
14865                                                            {
14866                                                              /* 33222222222211111111110000000000
14867                                                                 10987654321098765432109876543210
14868                                                                 001001x1xx10x10010xx1xxxxxxxxxxx
14869                                                                 incp.  */
14870                                                              return 1487;
14871                                                            }
14872                                                        }
14873                                                    }
14874                                                  else
14875                                                    {
14876                                                      if (((word >> 10) & 0x1) == 0)
14877                                                        {
14878                                                          if (((word >> 11) & 0x1) == 0)
14879                                                            {
14880                                                              /* 33222222222211111111110000000000
14881                                                                 10987654321098765432109876543210
14882                                                                 001001x1xx10xx1010xx00xxxxxxxxxx
14883                                                                 sqdecp.  */
14884                                                              return 1841;
14885                                                            }
14886                                                          else
14887                                                            {
14888                                                              /* 33222222222211111111110000000000
14889                                                                 10987654321098765432109876543210
14890                                                                 001001x1xx10xx1010xx10xxxxxxxxxx
14891                                                                 sqdecp.  */
14892                                                              return 1843;
14893                                                            }
14894                                                        }
14895                                                      else
14896                                                        {
14897                                                          /* 33222222222211111111110000000000
14898                                                             10987654321098765432109876543210
14899                                                             001001x1xx10xx1010xxx1xxxxxxxxxx
14900                                                             sqdecp.  */
14901                                                          return 1842;
14902                                                        }
14903                                                    }
14904                                                }
14905                                              else
14906                                                {
14907                                                  if (((word >> 10) & 0x1) == 0)
14908                                                    {
14909                                                      if (((word >> 11) & 0x1) == 0)
14910                                                        {
14911                                                          if (((word >> 17) & 0x1) == 0)
14912                                                            {
14913                                                              if (((word >> 18) & 0x1) == 0)
14914                                                                {
14915                                                                  /* 33222222222211111111110000000000
14916                                                                     10987654321098765432109876543210
14917                                                                     001001x1xx10x00110xx00xxxxxxxxxx
14918                                                                     uqincp.  */
14919                                                                  return 2003;
14920                                                                }
14921                                                              else
14922                                                                {
14923                                                                  /* 33222222222211111111110000000000
14924                                                                     10987654321098765432109876543210
14925                                                                     001001x1xx10x10110xx00xxxxxxxxxx
14926                                                                     decp.  */
14927                                                                  return 1361;
14928                                                                }
14929                                                            }
14930                                                          else
14931                                                            {
14932                                                              /* 33222222222211111111110000000000
14933                                                                 10987654321098765432109876543210
14934                                                                 001001x1xx10xx1110xx00xxxxxxxxxx
14935                                                                 uqdecp.  */
14936                                                              return 1989;
14937                                                            }
14938                                                        }
14939                                                      else
14940                                                        {
14941                                                          if (((word >> 17) & 0x1) == 0)
14942                                                            {
14943                                                              if (((word >> 18) & 0x1) == 0)
14944                                                                {
14945                                                                  /* 33222222222211111111110000000000
14946                                                                     10987654321098765432109876543210
14947                                                                     001001x1xx10x00110xx10xxxxxxxxxx
14948                                                                     uqincp.  */
14949                                                                  return 2004;
14950                                                                }
14951                                                              else
14952                                                                {
14953                                                                  /* 33222222222211111111110000000000
14954                                                                     10987654321098765432109876543210
14955                                                                     001001x1xx10x10110xx10xxxxxxxxxx
14956                                                                     decp.  */
14957                                                                  return 1362;
14958                                                                }
14959                                                            }
14960                                                          else
14961                                                            {
14962                                                              /* 33222222222211111111110000000000
14963                                                                 10987654321098765432109876543210
14964                                                                 001001x1xx10xx1110xx10xxxxxxxxxx
14965                                                                 uqdecp.  */
14966                                                              return 1990;
14967                                                            }
14968                                                        }
14969                                                    }
14970                                                  else
14971                                                    {
14972                                                      if (((word >> 17) & 0x1) == 0)
14973                                                        {
14974                                                          /* 33222222222211111111110000000000
14975                                                             10987654321098765432109876543210
14976                                                             001001x1xx10xx0110xxx1xxxxxxxxxx
14977                                                             uqincp.  */
14978                                                          return 2005;
14979                                                        }
14980                                                      else
14981                                                        {
14982                                                          /* 33222222222211111111110000000000
14983                                                             10987654321098765432109876543210
14984                                                             001001x1xx10xx1110xxx1xxxxxxxxxx
14985                                                             uqdecp.  */
14986                                                          return 1991;
14987                                                        }
14988                                                    }
14989                                                }
14990                                            }
14991                                          else
14992                                            {
14993                                              if (((word >> 22) & 0x1) == 0)
14994                                                {
14995                                                  if (((word >> 23) & 0x1) == 0)
14996                                                    {
14997                                                      /* 33222222222211111111110000000000
14998                                                         10987654321098765432109876543210
14999                                                         101001x10010xxxx10xxxxxxxxxxxxxx
15000                                                         ld1sh.  */
15001                                                      return 1579;
15002                                                    }
15003                                                  else
15004                                                    {
15005                                                      /* 33222222222211111111110000000000
15006                                                         10987654321098765432109876543210
15007                                                         101001x11010xxxx10xxxxxxxxxxxxxx
15008                                                         ld1sb.  */
15009                                                      return 1566;
15010                                                    }
15011                                                }
15012                                              else
15013                                                {
15014                                                  if (((word >> 23) & 0x1) == 0)
15015                                                    {
15016                                                      /* 33222222222211111111110000000000
15017                                                         10987654321098765432109876543210
15018                                                         101001x10110xxxx10xxxxxxxxxxxxxx
15019                                                         ld1w.  */
15020                                                      return 1598;
15021                                                    }
15022                                                  else
15023                                                    {
15024                                                      /* 33222222222211111111110000000000
15025                                                         10987654321098765432109876543210
15026                                                         101001x11110xxxx10xxxxxxxxxxxxxx
15027                                                         ld1d.  */
15028                                                      return 1518;
15029                                                    }
15030                                                }
15031                                            }
15032                                        }
15033                                      else
15034                                        {
15035                                          if (((word >> 22) & 0x1) == 0)
15036                                            {
15037                                              if (((word >> 23) & 0x1) == 0)
15038                                                {
15039                                                  /* 33222222222211111111110000000000
15040                                                     10987654321098765432109876543210
15041                                                     x01001x10011xxxx10xxxxxxxxxxxxxx
15042                                                     ldnf1sh.  */
15043                                                  return 1712;
15044                                                }
15045                                              else
15046                                                {
15047                                                  /* 33222222222211111111110000000000
15048                                                     10987654321098765432109876543210
15049                                                     x01001x11011xxxx10xxxxxxxxxxxxxx
15050                                                     ldnf1sb.  */
15051                                                  return 1709;
15052                                                }
15053                                            }
15054                                          else
15055                                            {
15056                                              if (((word >> 23) & 0x1) == 0)
15057                                                {
15058                                                  /* 33222222222211111111110000000000
15059                                                     10987654321098765432109876543210
15060                                                     x01001x10111xxxx10xxxxxxxxxxxxxx
15061                                                     ldnf1w.  */
15062                                                  return 1715;
15063                                                }
15064                                              else
15065                                                {
15066                                                  /* 33222222222211111111110000000000
15067                                                     10987654321098765432109876543210
15068                                                     x01001x11111xxxx10xxxxxxxxxxxxxx
15069                                                     ldnf1d.  */
15070                                                  return 1704;
15071                                                }
15072                                            }
15073                                        }
15074                                    }
15075                                  else
15076                                    {
15077                                      if (((word >> 31) & 0x1) == 0)
15078                                        {
15079                                          if (((word >> 16) & 0x1) == 0)
15080                                            {
15081                                              if (((word >> 17) & 0x1) == 0)
15082                                                {
15083                                                  if (((word >> 18) & 0x1) == 0)
15084                                                    {
15085                                                      if (((word >> 19) & 0x1) == 0)
15086                                                        {
15087                                                          if (((word >> 20) & 0x1) == 0)
15088                                                            {
15089                                                              /* 33222222222211111111110000000000
15090                                                                 10987654321098765432109876543210
15091                                                                 001001x1xx10000011xxxxxxxxxxxxxx
15092                                                                 add.  */
15093                                                              return 1275;
15094                                                            }
15095                                                          else
15096                                                            {
15097                                                              /* 33222222222211111111110000000000
15098                                                                 10987654321098765432109876543210
15099                                                                 001001x1xx11000011xxxxxxxxxxxxxx
15100                                                                 mul.  */
15101                                                              return 1744;
15102                                                            }
15103                                                        }
15104                                                      else
15105                                                        {
15106                                                          if (((word >> 20) & 0x1) == 0)
15107                                                            {
15108                                                              /* 33222222222211111111110000000000
15109                                                                 10987654321098765432109876543210
15110                                                                 001001x1xx10100011xxxxxxxxxxxxxx
15111                                                                 smax.  */
15112                                                              return 1823;
15113                                                            }
15114                                                          else
15115                                                            {
15116                                                              /* 33222222222211111111110000000000
15117                                                                 10987654321098765432109876543210
15118                                                                 001001x1xx11100011xxxxxxxxxxxxxx
15119                                                                 dup.  */
15120                                                              return 1367;
15121                                                            }
15122                                                        }
15123                                                    }
15124                                                  else
15125                                                    {
15126                                                      /* 33222222222211111111110000000000
15127                                                         10987654321098765432109876543210
15128                                                         001001x1xx1xx10011xxxxxxxxxxxxxx
15129                                                         sqadd.  */
15130                                                      return 1832;
15131                                                    }
15132                                                }
15133                                              else
15134                                                {
15135                                                  if (((word >> 18) & 0x1) == 0)
15136                                                    {
15137                                                      /* 33222222222211111111110000000000
15138                                                         10987654321098765432109876543210
15139                                                         001001x1xx1xx01011xxxxxxxxxxxxxx
15140                                                         smin.  */
15141                                                      return 1826;
15142                                                    }
15143                                                  else
15144                                                    {
15145                                                      /* 33222222222211111111110000000000
15146                                                         10987654321098765432109876543210
15147                                                         001001x1xx1xx11011xxxxxxxxxxxxxx
15148                                                         sqsub.  */
15149                                                      return 1862;
15150                                                    }
15151                                                }
15152                                            }
15153                                          else
15154                                            {
15155                                              if (((word >> 17) & 0x1) == 0)
15156                                                {
15157                                                  if (((word >> 18) & 0x1) == 0)
15158                                                    {
15159                                                      if (((word >> 19) & 0x1) == 0)
15160                                                        {
15161                                                          /* 33222222222211111111110000000000
15162                                                             10987654321098765432109876543210
15163                                                             001001x1xx1x000111xxxxxxxxxxxxxx
15164                                                             sub.  */
15165                                                          return 1944;
15166                                                        }
15167                                                      else
15168                                                        {
15169                                                          if (((word >> 20) & 0x1) == 0)
15170                                                            {
15171                                                              /* 33222222222211111111110000000000
15172                                                                 10987654321098765432109876543210
15173                                                                 001001x1xx10100111xxxxxxxxxxxxxx
15174                                                                 umax.  */
15175                                                              return 1972;
15176                                                            }
15177                                                          else
15178                                                            {
15179                                                              /* 33222222222211111111110000000000
15180                                                                 10987654321098765432109876543210
15181                                                                 001001x1xx11100111xxxxxxxxxxxxxx
15182                                                                 fdup.  */
15183                                                              return 1423;
15184                                                            }
15185                                                        }
15186                                                    }
15187                                                  else
15188                                                    {
15189                                                      /* 33222222222211111111110000000000
15190                                                         10987654321098765432109876543210
15191                                                         001001x1xx1xx10111xxxxxxxxxxxxxx
15192                                                         uqadd.  */
15193                                                      return 1980;
15194                                                    }
15195                                                }
15196                                              else
15197                                                {
15198                                                  if (((word >> 18) & 0x1) == 0)
15199                                                    {
15200                                                      if (((word >> 19) & 0x1) == 0)
15201                                                        {
15202                                                          /* 33222222222211111111110000000000
15203                                                             10987654321098765432109876543210
15204                                                             001001x1xx1x001111xxxxxxxxxxxxxx
15205                                                             subr.  */
15206                                                          return 1946;
15207                                                        }
15208                                                      else
15209                                                        {
15210                                                          /* 33222222222211111111110000000000
15211                                                             10987654321098765432109876543210
15212                                                             001001x1xx1x101111xxxxxxxxxxxxxx
15213                                                             umin.  */
15214                                                          return 1975;
15215                                                        }
15216                                                    }
15217                                                  else
15218                                                    {
15219                                                      /* 33222222222211111111110000000000
15220                                                         10987654321098765432109876543210
15221                                                         001001x1xx1xx11111xxxxxxxxxxxxxx
15222                                                         uqsub.  */
15223                                                      return 2010;
15224                                                    }
15225                                                }
15226                                            }
15227                                        }
15228                                      else
15229                                        {
15230                                          if (((word >> 13) & 0x1) == 0)
15231                                            {
15232                                              if (((word >> 22) & 0x1) == 0)
15233                                                {
15234                                                  if (((word >> 23) & 0x1) == 0)
15235                                                    {
15236                                                      /* 33222222222211111111110000000000
15237                                                         10987654321098765432109876543210
15238                                                         101001x1001xxxxx110xxxxxxxxxxxxx
15239                                                         ld2w.  */
15240                                                      return 1606;
15241                                                    }
15242                                                  else
15243                                                    {
15244                                                      /* 33222222222211111111110000000000
15245                                                         10987654321098765432109876543210
15246                                                         101001x1101xxxxx110xxxxxxxxxxxxx
15247                                                         ld2d.  */
15248                                                      return 1602;
15249                                                    }
15250                                                }
15251                                              else
15252                                                {
15253                                                  if (((word >> 23) & 0x1) == 0)
15254                                                    {
15255                                                      /* 33222222222211111111110000000000
15256                                                         10987654321098765432109876543210
15257                                                         101001x1011xxxxx110xxxxxxxxxxxxx
15258                                                         ld4w.  */
15259                                                      return 1622;
15260                                                    }
15261                                                  else
15262                                                    {
15263                                                      /* 33222222222211111111110000000000
15264                                                         10987654321098765432109876543210
15265                                                         101001x1111xxxxx110xxxxxxxxxxxxx
15266                                                         ld4d.  */
15267                                                      return 1618;
15268                                                    }
15269                                                }
15270                                            }
15271                                          else
15272                                            {
15273                                              if (((word >> 22) & 0x1) == 0)
15274                                                {
15275                                                  if (((word >> 23) & 0x1) == 0)
15276                                                    {
15277                                                      /* 33222222222211111111110000000000
15278                                                         10987654321098765432109876543210
15279                                                         101001x1001xxxxx111xxxxxxxxxxxxx
15280                                                         ld2w.  */
15281                                                      return 1607;
15282                                                    }
15283                                                  else
15284                                                    {
15285                                                      /* 33222222222211111111110000000000
15286                                                         10987654321098765432109876543210
15287                                                         101001x1101xxxxx111xxxxxxxxxxxxx
15288                                                         ld2d.  */
15289                                                      return 1603;
15290                                                    }
15291                                                }
15292                                              else
15293                                                {
15294                                                  if (((word >> 23) & 0x1) == 0)
15295                                                    {
15296                                                      /* 33222222222211111111110000000000
15297                                                         10987654321098765432109876543210
15298                                                         101001x1011xxxxx111xxxxxxxxxxxxx
15299                                                         ld4w.  */
15300                                                      return 1623;
15301                                                    }
15302                                                  else
15303                                                    {
15304                                                      /* 33222222222211111111110000000000
15305                                                         10987654321098765432109876543210
15306                                                         101001x1111xxxxx111xxxxxxxxxxxxx
15307                                                         ld4d.  */
15308                                                      return 1619;
15309                                                    }
15310                                                }
15311                                            }
15312                                        }
15313                                    }
15314                                }
15315                              else
15316                                {
15317                                  if (((word >> 13) & 0x1) == 0)
15318                                    {
15319                                      if (((word >> 31) & 0x1) == 0)
15320                                        {
15321                                          if (((word >> 14) & 0x1) == 0)
15322                                            {
15323                                              /* 33222222222211111111110000000000
15324                                                 10987654321098765432109876543210
15325                                                 011001x1xx1xxxxx100xxxxxxxxxxxxx
15326                                                 fmad.  */
15327                                              return 1425;
15328                                            }
15329                                          else
15330                                            {
15331                                              /* 33222222222211111111110000000000
15332                                                 10987654321098765432109876543210
15333                                                 011001x1xx1xxxxx110xxxxxxxxxxxxx
15334                                                 fnmad.  */
15335                                              return 1455;
15336                                            }
15337                                        }
15338                                      else
15339                                        {
15340                                          if (((word >> 22) & 0x1) == 0)
15341                                            {
15342                                              if (((word >> 23) & 0x1) == 0)
15343                                                {
15344                                                  /* 33222222222211111111110000000000
15345                                                     10987654321098765432109876543210
15346                                                     111001x1001xxxxx1x0xxxxxxxxxxxxx
15347                                                     st1w.  */
15348                                                  return 1899;
15349                                                }
15350                                              else
15351                                                {
15352                                                  /* 33222222222211111111110000000000
15353                                                     10987654321098765432109876543210
15354                                                     111001x1101xxxxx1x0xxxxxxxxxxxxx
15355                                                     st1d.  */
15356                                                  return 1878;
15357                                                }
15358                                            }
15359                                          else
15360                                            {
15361                                              /* 33222222222211111111110000000000
15362                                                 10987654321098765432109876543210
15363                                                 111001x1x11xxxxx1x0xxxxxxxxxxxxx
15364                                                 st1w.  */
15365                                              return 1904;
15366                                            }
15367                                        }
15368                                    }
15369                                  else
15370                                    {
15371                                      if (((word >> 14) & 0x1) == 0)
15372                                        {
15373                                          if (((word >> 31) & 0x1) == 0)
15374                                            {
15375                                              /* 33222222222211111111110000000000
15376                                                 10987654321098765432109876543210
15377                                                 011001x1xx1xxxxx101xxxxxxxxxxxxx
15378                                                 fmsb.  */
15379                                              return 1446;
15380                                            }
15381                                          else
15382                                            {
15383                                              if (((word >> 22) & 0x1) == 0)
15384                                                {
15385                                                  if (((word >> 23) & 0x1) == 0)
15386                                                    {
15387                                                      /* 33222222222211111111110000000000
15388                                                         10987654321098765432109876543210
15389                                                         111001x1001xxxxx101xxxxxxxxxxxxx
15390                                                         st1w.  */
15391                                                      return 1900;
15392                                                    }
15393                                                  else
15394                                                    {
15395                                                      /* 33222222222211111111110000000000
15396                                                         10987654321098765432109876543210
15397                                                         111001x1101xxxxx101xxxxxxxxxxxxx
15398                                                         st1d.  */
15399                                                      return 1879;
15400                                                    }
15401                                                }
15402                                              else
15403                                                {
15404                                                  /* 33222222222211111111110000000000
15405                                                     10987654321098765432109876543210
15406                                                     111001x1x11xxxxx101xxxxxxxxxxxxx
15407                                                     st1w.  */
15408                                                  return 1907;
15409                                                }
15410                                            }
15411                                        }
15412                                      else
15413                                        {
15414                                          if (((word >> 31) & 0x1) == 0)
15415                                            {
15416                                              /* 33222222222211111111110000000000
15417                                                 10987654321098765432109876543210
15418                                                 011001x1xx1xxxxx111xxxxxxxxxxxxx
15419                                                 fnmsb.  */
15420                                              return 1458;
15421                                            }
15422                                          else
15423                                            {
15424                                              if (((word >> 20) & 0x1) == 0)
15425                                                {
15426                                                  if (((word >> 23) & 0x1) == 0)
15427                                                    {
15428                                                      /* 33222222222211111111110000000000
15429                                                         10987654321098765432109876543210
15430                                                         111001x10x10xxxx111xxxxxxxxxxxxx
15431                                                         st1w.  */
15432                                                      return 1908;
15433                                                    }
15434                                                  else
15435                                                    {
15436                                                      /* 33222222222211111111110000000000
15437                                                         10987654321098765432109876543210
15438                                                         111001x11x10xxxx111xxxxxxxxxxxxx
15439                                                         st1d.  */
15440                                                      return 1882;
15441                                                    }
15442                                                }
15443                                              else
15444                                                {
15445                                                  if (((word >> 22) & 0x1) == 0)
15446                                                    {
15447                                                      if (((word >> 23) & 0x1) == 0)
15448                                                        {
15449                                                          /* 33222222222211111111110000000000
15450                                                             10987654321098765432109876543210
15451                                                             111001x10011xxxx111xxxxxxxxxxxxx
15452                                                             st2w.  */
15453                                                          return 1916;
15454                                                        }
15455                                                      else
15456                                                        {
15457                                                          /* 33222222222211111111110000000000
15458                                                             10987654321098765432109876543210
15459                                                             111001x11011xxxx111xxxxxxxxxxxxx
15460                                                             st2d.  */
15461                                                          return 1912;
15462                                                        }
15463                                                    }
15464                                                  else
15465                                                    {
15466                                                      if (((word >> 23) & 0x1) == 0)
15467                                                        {
15468                                                          /* 33222222222211111111110000000000
15469                                                             10987654321098765432109876543210
15470                                                             111001x10111xxxx111xxxxxxxxxxxxx
15471                                                             st4w.  */
15472                                                          return 1932;
15473                                                        }
15474                                                      else
15475                                                        {
15476                                                          /* 33222222222211111111110000000000
15477                                                             10987654321098765432109876543210
15478                                                             111001x11111xxxx111xxxxxxxxxxxxx
15479                                                             st4d.  */
15480                                                          return 1928;
15481                                                        }
15482                                                    }
15483                                                }
15484                                            }
15485                                        }
15486                                    }
15487                                }
15488                            }
15489                        }
15490                    }
15491                }
15492            }
15493          else
15494            {
15495              if (((word >> 29) & 0x1) == 0)
15496                {
15497                  if (((word >> 30) & 0x1) == 0)
15498                    {
15499                      if (((word >> 31) & 0x1) == 0)
15500                        {
15501                          /* 33222222222211111111110000000000
15502                             10987654321098765432109876543210
15503                             000101xxxxxxxxxxxxxxxxxxxxxxxxxx
15504                             b.  */
15505                          return 636;
15506                        }
15507                      else
15508                        {
15509                          /* 33222222222211111111110000000000
15510                             10987654321098765432109876543210
15511                             100101xxxxxxxxxxxxxxxxxxxxxxxxxx
15512                             bl.  */
15513                          return 637;
15514                        }
15515                    }
15516                  else
15517                    {
15518                      if (((word >> 24) & 0x1) == 0)
15519                        {
15520                          if (((word >> 4) & 0x1) == 0)
15521                            {
15522                              if (((word >> 25) & 0x1) == 0)
15523                                {
15524                                  if (((word >> 31) & 0x1) == 0)
15525                                    {
15526                                      /* 33222222222211111111110000000000
15527                                         10987654321098765432109876543210
15528                                         01010100xxxxxxxxxxxxxxxxxxx0xxxx
15529                                         b.c.  */
15530                                      return 657;
15531                                    }
15532                                  else
15533                                    {
15534                                      if (((word >> 0) & 0x1) == 0)
15535                                        {
15536                                          if (((word >> 1) & 0x1) == 0)
15537                                            {
15538                                              if (((word >> 21) & 0x1) == 0)
15539                                                {
15540                                                  /* 33222222222211111111110000000000
15541                                                     10987654321098765432109876543210
15542                                                     11010100xx0xxxxxxxxxxxxxxxx0xx00
15543                                                     hlt.  */
15544                                                  return 753;
15545                                                }
15546                                              else
15547                                                {
15548                                                  if (((word >> 22) & 0x1) == 0)
15549                                                    {
15550                                                      /* 33222222222211111111110000000000
15551                                                         10987654321098765432109876543210
15552                                                         11010100x01xxxxxxxxxxxxxxxx0xx00
15553                                                         brk.  */
15554                                                      return 752;
15555                                                    }
15556                                                  else
15557                                                    {
15558                                                      /* 33222222222211111111110000000000
15559                                                         10987654321098765432109876543210
15560                                                         11010100x11xxxxxxxxxxxxxxxx0xx00
15561                                                         tcancel.  */
15562                                                      return 1191;
15563                                                    }
15564                                                }
15565                                            }
15566                                          else
15567                                            {
15568                                              if (((word >> 21) & 0x1) == 0)
15569                                                {
15570                                                  /* 33222222222211111111110000000000
15571                                                     10987654321098765432109876543210
15572                                                     11010100xx0xxxxxxxxxxxxxxxx0xx10
15573                                                     hvc.  */
15574                                                  return 750;
15575                                                }
15576                                              else
15577                                                {
15578                                                  /* 33222222222211111111110000000000
15579                                                     10987654321098765432109876543210
15580                                                     11010100xx1xxxxxxxxxxxxxxxx0xx10
15581                                                     dcps2.  */
15582                                                  return 755;
15583                                                }
15584                                            }
15585                                        }
15586                                      else
15587                                        {
15588                                          if (((word >> 1) & 0x1) == 0)
15589                                            {
15590                                              if (((word >> 21) & 0x1) == 0)
15591                                                {
15592                                                  /* 33222222222211111111110000000000
15593                                                     10987654321098765432109876543210
15594                                                     11010100xx0xxxxxxxxxxxxxxxx0xx01
15595                                                     svc.  */
15596                                                  return 749;
15597                                                }
15598                                              else
15599                                                {
15600                                                  /* 33222222222211111111110000000000
15601                                                     10987654321098765432109876543210
15602                                                     11010100xx1xxxxxxxxxxxxxxxx0xx01
15603                                                     dcps1.  */
15604                                                  return 754;
15605                                                }
15606                                            }
15607                                          else
15608                                            {
15609                                              if (((word >> 21) & 0x1) == 0)
15610                                                {
15611                                                  /* 33222222222211111111110000000000
15612                                                     10987654321098765432109876543210
15613                                                     11010100xx0xxxxxxxxxxxxxxxx0xx11
15614                                                     smc.  */
15615                                                  return 751;
15616                                                }
15617                                              else
15618                                                {
15619                                                  /* 33222222222211111111110000000000
15620                                                     10987654321098765432109876543210
15621                                                     11010100xx1xxxxxxxxxxxxxxxx0xx11
15622                                                     dcps3.  */
15623                                                  return 756;
15624                                                }
15625                                            }
15626                                        }
15627                                    }
15628                                }
15629                              else
15630                                {
15631                                  if (((word >> 21) & 0x1) == 0)
15632                                    {
15633                                      if (((word >> 22) & 0x1) == 0)
15634                                        {
15635                                          if (((word >> 23) & 0x1) == 0)
15636                                            {
15637                                              /* 33222222222211111111110000000000
15638                                                 10987654321098765432109876543210
15639                                                 x1010110000xxxxxxxxxxxxxxxx0xxxx
15640                                                 br.  */
15641                                              return 638;
15642                                            }
15643                                          else
15644                                            {
15645                                              /* 33222222222211111111110000000000
15646                                                 10987654321098765432109876543210
15647                                                 x1010110100xxxxxxxxxxxxxxxx0xxxx
15648                                                 eret.  */
15649                                              return 641;
15650                                            }
15651                                        }
15652                                      else
15653                                        {
15654                                          /* 33222222222211111111110000000000
15655                                             10987654321098765432109876543210
15656                                             x1010110x10xxxxxxxxxxxxxxxx0xxxx
15657                                             ret.  */
15658                                          return 640;
15659                                        }
15660                                    }
15661                                  else
15662                                    {
15663                                      if (((word >> 23) & 0x1) == 0)
15664                                        {
15665                                          /* 33222222222211111111110000000000
15666                                             10987654321098765432109876543210
15667                                             x10101100x1xxxxxxxxxxxxxxxx0xxxx
15668                                             blr.  */
15669                                          return 639;
15670                                        }
15671                                      else
15672                                        {
15673                                          /* 33222222222211111111110000000000
15674                                             10987654321098765432109876543210
15675                                             x10101101x1xxxxxxxxxxxxxxxx0xxxx
15676                                             drps.  */
15677                                          return 642;
15678                                        }
15679                                    }
15680                                }
15681                            }
15682                          else
15683                            {
15684                              if (((word >> 10) & 0x1) == 0)
15685                                {
15686                                  if (((word >> 21) & 0x1) == 0)
15687                                    {
15688                                      if (((word >> 22) & 0x1) == 0)
15689                                        {
15690                                          if (((word >> 23) & 0x1) == 0)
15691                                            {
15692                                              /* 33222222222211111111110000000000
15693                                                 10987654321098765432109876543210
15694                                                 x10101x0000xxxxxxxxxx0xxxxx1xxxx
15695                                                 braaz.  */
15696                                              return 647;
15697                                            }
15698                                          else
15699                                            {
15700                                              /* 33222222222211111111110000000000
15701                                                 10987654321098765432109876543210
15702                                                 x10101x0100xxxxxxxxxx0xxxxx1xxxx
15703                                                 eretaa.  */
15704                                              return 653;
15705                                            }
15706                                        }
15707                                      else
15708                                        {
15709                                          /* 33222222222211111111110000000000
15710                                             10987654321098765432109876543210
15711                                             x10101x0x10xxxxxxxxxx0xxxxx1xxxx
15712                                             retaa.  */
15713                                          return 651;
15714                                        }
15715                                    }
15716                                  else
15717                                    {
15718                                      /* 33222222222211111111110000000000
15719                                         10987654321098765432109876543210
15720                                         x10101x0xx1xxxxxxxxxx0xxxxx1xxxx
15721                                         blraaz.  */
15722                                      return 649;
15723                                    }
15724                                }
15725                              else
15726                                {
15727                                  if (((word >> 21) & 0x1) == 0)
15728                                    {
15729                                      if (((word >> 22) & 0x1) == 0)
15730                                        {
15731                                          if (((word >> 23) & 0x1) == 0)
15732                                            {
15733                                              /* 33222222222211111111110000000000
15734                                                 10987654321098765432109876543210
15735                                                 x10101x0000xxxxxxxxxx1xxxxx1xxxx
15736                                                 brabz.  */
15737                                              return 648;
15738                                            }
15739                                          else
15740                                            {
15741                                              /* 33222222222211111111110000000000
15742                                                 10987654321098765432109876543210
15743                                                 x10101x0100xxxxxxxxxx1xxxxx1xxxx
15744                                                 eretab.  */
15745                                              return 654;
15746                                            }
15747                                        }
15748                                      else
15749                                        {
15750                                          /* 33222222222211111111110000000000
15751                                             10987654321098765432109876543210
15752                                             x10101x0x10xxxxxxxxxx1xxxxx1xxxx
15753                                             retab.  */
15754                                          return 652;
15755                                        }
15756                                    }
15757                                  else
15758                                    {
15759                                      /* 33222222222211111111110000000000
15760                                         10987654321098765432109876543210
15761                                         x10101x0xx1xxxxxxxxxx1xxxxx1xxxx
15762                                         blrabz.  */
15763                                      return 650;
15764                                    }
15765                                }
15766                            }
15767                        }
15768                      else
15769                        {
15770                          if (((word >> 21) & 0x1) == 0)
15771                            {
15772                              if (((word >> 25) & 0x1) == 0)
15773                                {
15774                                  /* 33222222222211111111110000000000
15775                                     10987654321098765432109876543210
15776                                     x1010101xx0xxxxxxxxxxxxxxxxxxxxx
15777                                     xaflag.  */
15778                                  return 810;
15779                                }
15780                              else
15781                                {
15782                                  if (((word >> 10) & 0x1) == 0)
15783                                    {
15784                                      /* 33222222222211111111110000000000
15785                                         10987654321098765432109876543210
15786                                         x1010111xx0xxxxxxxxxx0xxxxxxxxxx
15787                                         braa.  */
15788                                      return 643;
15789                                    }
15790                                  else
15791                                    {
15792                                      /* 33222222222211111111110000000000
15793                                         10987654321098765432109876543210
15794                                         x1010111xx0xxxxxxxxxx1xxxxxxxxxx
15795                                         brab.  */
15796                                      return 644;
15797                                    }
15798                                }
15799                            }
15800                          else
15801                            {
15802                              if (((word >> 25) & 0x1) == 0)
15803                                {
15804                                  /* 33222222222211111111110000000000
15805                                     10987654321098765432109876543210
15806                                     x1010101xx1xxxxxxxxxxxxxxxxxxxxx
15807                                     tstart.  */
15808                                  return 1188;
15809                                }
15810                              else
15811                                {
15812                                  if (((word >> 10) & 0x1) == 0)
15813                                    {
15814                                      /* 33222222222211111111110000000000
15815                                         10987654321098765432109876543210
15816                                         x1010111xx1xxxxxxxxxx0xxxxxxxxxx
15817                                         blraa.  */
15818                                      return 645;
15819                                    }
15820                                  else
15821                                    {
15822                                      /* 33222222222211111111110000000000
15823                                         10987654321098765432109876543210
15824                                         x1010111xx1xxxxxxxxxx1xxxxxxxxxx
15825                                         blrab.  */
15826                                      return 646;
15827                                    }
15828                                }
15829                            }
15830                        }
15831                    }
15832                }
15833              else
15834                {
15835                  if (((word >> 24) & 0x1) == 0)
15836                    {
15837                      if (((word >> 25) & 0x1) == 0)
15838                        {
15839                          /* 33222222222211111111110000000000
15840                             10987654321098765432109876543210
15841                             xx110100xxxxxxxxxxxxxxxxxxxxxxxx
15842                             cbz.  */
15843                          return 655;
15844                        }
15845                      else
15846                        {
15847                          /* 33222222222211111111110000000000
15848                             10987654321098765432109876543210
15849                             xx110110xxxxxxxxxxxxxxxxxxxxxxxx
15850                             tbz.  */
15851                          return 1236;
15852                        }
15853                    }
15854                  else
15855                    {
15856                      if (((word >> 25) & 0x1) == 0)
15857                        {
15858                          /* 33222222222211111111110000000000
15859                             10987654321098765432109876543210
15860                             xx110101xxxxxxxxxxxxxxxxxxxxxxxx
15861                             cbnz.  */
15862                          return 656;
15863                        }
15864                      else
15865                        {
15866                          /* 33222222222211111111110000000000
15867                             10987654321098765432109876543210
15868                             xx110111xxxxxxxxxxxxxxxxxxxxxxxx
15869                             tbnz.  */
15870                          return 1237;
15871                        }
15872                    }
15873                }
15874            }
15875        }
15876      else
15877        {
15878          if (((word >> 25) & 0x1) == 0)
15879            {
15880              if (((word >> 28) & 0x1) == 0)
15881                {
15882                  if (((word >> 22) & 0x1) == 0)
15883                    {
15884                      if (((word >> 23) & 0x1) == 0)
15885                        {
15886                          if (((word >> 24) & 0x1) == 0)
15887                            {
15888                              if (((word >> 29) & 0x1) == 0)
15889                                {
15890                                  /* 33222222222211111111110000000000
15891                                     10987654321098765432109876543210
15892                                     xx00110000xxxxxxxxxxxxxxxxxxxxxx
15893                                     st4.  */
15894                                  return 440;
15895                                }
15896                              else
15897                                {
15898                                  /* 33222222222211111111110000000000
15899                                     10987654321098765432109876543210
15900                                     xx10110000xxxxxxxxxxxxxxxxxxxxxx
15901                                     stnp.  */
15902                                  return 972;
15903                                }
15904                            }
15905                          else
15906                            {
15907                              if (((word >> 29) & 0x1) == 0)
15908                                {
15909                                  if (((word >> 13) & 0x1) == 0)
15910                                    {
15911                                      if (((word >> 21) & 0x1) == 0)
15912                                        {
15913                                          /* 33222222222211111111110000000000
15914                                             10987654321098765432109876543210
15915                                             xx001101000xxxxxxx0xxxxxxxxxxxxx
15916                                             st1.  */
15917                                          return 456;
15918                                        }
15919                                      else
15920                                        {
15921                                          /* 33222222222211111111110000000000
15922                                             10987654321098765432109876543210
15923                                             xx001101001xxxxxxx0xxxxxxxxxxxxx
15924                                             st2.  */
15925                                          return 458;
15926                                        }
15927                                    }
15928                                  else
15929                                    {
15930                                      if (((word >> 21) & 0x1) == 0)
15931                                        {
15932                                          /* 33222222222211111111110000000000
15933                                             10987654321098765432109876543210
15934                                             xx001101000xxxxxxx1xxxxxxxxxxxxx
15935                                             st3.  */
15936                                          return 457;
15937                                        }
15938                                      else
15939                                        {
15940                                          /* 33222222222211111111110000000000
15941                                             10987654321098765432109876543210
15942                                             xx001101001xxxxxxx1xxxxxxxxxxxxx
15943                                             st4.  */
15944                                          return 459;
15945                                        }
15946                                    }
15947                                }
15948                              else
15949                                {
15950                                  /* 33222222222211111111110000000000
15951                                     10987654321098765432109876543210
15952                                     xx10110100xxxxxxxxxxxxxxxxxxxxxx
15953                                     stp.  */
15954                                  return 976;
15955                                }
15956                            }
15957                        }
15958                      else
15959                        {
15960                          if (((word >> 29) & 0x1) == 0)
15961                            {
15962                              if (((word >> 21) & 0x1) == 0)
15963                                {
15964                                  if (((word >> 24) & 0x1) == 0)
15965                                    {
15966                                      /* 33222222222211111111110000000000
15967                                         10987654321098765432109876543210
15968                                         xx001100100xxxxxxxxxxxxxxxxxxxxx
15969                                         st4.  */
15970                                      return 448;
15971                                    }
15972                                  else
15973                                    {
15974                                      if (((word >> 13) & 0x1) == 0)
15975                                        {
15976                                          /* 33222222222211111111110000000000
15977                                             10987654321098765432109876543210
15978                                             xx001101100xxxxxxx0xxxxxxxxxxxxx
15979                                             st1.  */
15980                                          return 468;
15981                                        }
15982                                      else
15983                                        {
15984                                          /* 33222222222211111111110000000000
15985                                             10987654321098765432109876543210
15986                                             xx001101100xxxxxxx1xxxxxxxxxxxxx
15987                                             st3.  */
15988                                          return 469;
15989                                        }
15990                                    }
15991                                }
15992                              else
15993                                {
15994                                  if (((word >> 13) & 0x1) == 0)
15995                                    {
15996                                      /* 33222222222211111111110000000000
15997                                         10987654321098765432109876543210
15998                                         xx00110x101xxxxxxx0xxxxxxxxxxxxx
15999                                         st2.  */
16000                                      return 470;
16001                                    }
16002                                  else
16003                                    {
16004                                      /* 33222222222211111111110000000000
16005                                         10987654321098765432109876543210
16006                                         xx00110x101xxxxxxx1xxxxxxxxxxxxx
16007                                         st4.  */
16008                                      return 471;
16009                                    }
16010                                }
16011                            }
16012                          else
16013                            {
16014                              /* 33222222222211111111110000000000
16015                                 10987654321098765432109876543210
16016                                 xx10110x10xxxxxxxxxxxxxxxxxxxxxx
16017                                 stp.  */
16018                              return 982;
16019                            }
16020                        }
16021                    }
16022                  else
16023                    {
16024                      if (((word >> 23) & 0x1) == 0)
16025                        {
16026                          if (((word >> 24) & 0x1) == 0)
16027                            {
16028                              if (((word >> 29) & 0x1) == 0)
16029                                {
16030                                  /* 33222222222211111111110000000000
16031                                     10987654321098765432109876543210
16032                                     xx00110001xxxxxxxxxxxxxxxxxxxxxx
16033                                     ld4.  */
16034                                  return 444;
16035                                }
16036                              else
16037                                {
16038                                  /* 33222222222211111111110000000000
16039                                     10987654321098765432109876543210
16040                                     xx10110001xxxxxxxxxxxxxxxxxxxxxx
16041                                     ldnp.  */
16042                                  return 973;
16043                                }
16044                            }
16045                          else
16046                            {
16047                              if (((word >> 29) & 0x1) == 0)
16048                                {
16049                                  if (((word >> 13) & 0x1) == 0)
16050                                    {
16051                                      if (((word >> 21) & 0x1) == 0)
16052                                        {
16053                                          /* 33222222222211111111110000000000
16054                                             10987654321098765432109876543210
16055                                             xx001101010xxxxxxx0xxxxxxxxxxxxx
16056                                             ld1.  */
16057                                          return 460;
16058                                        }
16059                                      else
16060                                        {
16061                                          /* 33222222222211111111110000000000
16062                                             10987654321098765432109876543210
16063                                             xx001101011xxxxxxx0xxxxxxxxxxxxx
16064                                             ld2.  */
16065                                          return 464;
16066                                        }
16067                                    }
16068                                  else
16069                                    {
16070                                      if (((word >> 21) & 0x1) == 0)
16071                                        {
16072                                          /* 33222222222211111111110000000000
16073                                             10987654321098765432109876543210
16074                                             xx001101010xxxxxxx1xxxxxxxxxxxxx
16075                                             ld3.  */
16076                                          return 461;
16077                                        }
16078                                      else
16079                                        {
16080                                          /* 33222222222211111111110000000000
16081                                             10987654321098765432109876543210
16082                                             xx001101011xxxxxxx1xxxxxxxxxxxxx
16083                                             ld4.  */
16084                                          return 465;
16085                                        }
16086                                    }
16087                                }
16088                              else
16089                                {
16090                                  /* 33222222222211111111110000000000
16091                                     10987654321098765432109876543210
16092                                     xx10110101xxxxxxxxxxxxxxxxxxxxxx
16093                                     ldp.  */
16094                                  return 977;
16095                                }
16096                            }
16097                        }
16098                      else
16099                        {
16100                          if (((word >> 29) & 0x1) == 0)
16101                            {
16102                              if (((word >> 21) & 0x1) == 0)
16103                                {
16104                                  if (((word >> 24) & 0x1) == 0)
16105                                    {
16106                                      /* 33222222222211111111110000000000
16107                                         10987654321098765432109876543210
16108                                         xx001100110xxxxxxxxxxxxxxxxxxxxx
16109                                         ld4.  */
16110                                      return 452;
16111                                    }
16112                                  else
16113                                    {
16114                                      if (((word >> 13) & 0x1) == 0)
16115                                        {
16116                                          /* 33222222222211111111110000000000
16117                                             10987654321098765432109876543210
16118                                             xx001101110xxxxxxx0xxxxxxxxxxxxx
16119                                             ld1.  */
16120                                          return 472;
16121                                        }
16122                                      else
16123                                        {
16124                                          /* 33222222222211111111110000000000
16125                                             10987654321098765432109876543210
16126                                             xx001101110xxxxxxx1xxxxxxxxxxxxx
16127                                             ld3.  */
16128                                          return 473;
16129                                        }
16130                                    }
16131                                }
16132                              else
16133                                {
16134                                  if (((word >> 13) & 0x1) == 0)
16135                                    {
16136                                      /* 33222222222211111111110000000000
16137                                         10987654321098765432109876543210
16138                                         xx00110x111xxxxxxx0xxxxxxxxxxxxx
16139                                         ld2.  */
16140                                      return 476;
16141                                    }
16142                                  else
16143                                    {
16144                                      /* 33222222222211111111110000000000
16145                                         10987654321098765432109876543210
16146                                         xx00110x111xxxxxxx1xxxxxxxxxxxxx
16147                                         ld4.  */
16148                                      return 477;
16149                                    }
16150                                }
16151                            }
16152                          else
16153                            {
16154                              /* 33222222222211111111110000000000
16155                                 10987654321098765432109876543210
16156                                 xx10110x11xxxxxxxxxxxxxxxxxxxxxx
16157                                 ldp.  */
16158                              return 983;
16159                            }
16160                        }
16161                    }
16162                }
16163              else
16164                {
16165                  if (((word >> 24) & 0x1) == 0)
16166                    {
16167                      if (((word >> 29) & 0x1) == 0)
16168                        {
16169                          /* 33222222222211111111110000000000
16170                             10987654321098765432109876543210
16171                             xx011100xxxxxxxxxxxxxxxxxxxxxxxx
16172                             ldr.  */
16173                          return 987;
16174                        }
16175                      else
16176                        {
16177                          if (((word >> 10) & 0x1) == 0)
16178                            {
16179                              if (((word >> 11) & 0x1) == 0)
16180                                {
16181                                  if (((word >> 22) & 0x1) == 0)
16182                                    {
16183                                      /* 33222222222211111111110000000000
16184                                         10987654321098765432109876543210
16185                                         xx111100x0xxxxxxxxxx00xxxxxxxxxx
16186                                         stur.  */
16187                                      return 924;
16188                                    }
16189                                  else
16190                                    {
16191                                      /* 33222222222211111111110000000000
16192                                         10987654321098765432109876543210
16193                                         xx111100x1xxxxxxxxxx00xxxxxxxxxx
16194                                         ldur.  */
16195                                      return 925;
16196                                    }
16197                                }
16198                              else
16199                                {
16200                                  if (((word >> 22) & 0x1) == 0)
16201                                    {
16202                                      /* 33222222222211111111110000000000
16203                                         10987654321098765432109876543210
16204                                         xx111100x0xxxxxxxxxx10xxxxxxxxxx
16205                                         str.  */
16206                                      return 903;
16207                                    }
16208                                  else
16209                                    {
16210                                      /* 33222222222211111111110000000000
16211                                         10987654321098765432109876543210
16212                                         xx111100x1xxxxxxxxxx10xxxxxxxxxx
16213                                         ldr.  */
16214                                      return 904;
16215                                    }
16216                                }
16217                            }
16218                          else
16219                            {
16220                              if (((word >> 22) & 0x1) == 0)
16221                                {
16222                                  /* 33222222222211111111110000000000
16223                                     10987654321098765432109876543210
16224                                     xx111100x0xxxxxxxxxxx1xxxxxxxxxx
16225                                     str.  */
16226                                  return 872;
16227                                }
16228                              else
16229                                {
16230                                  /* 33222222222211111111110000000000
16231                                     10987654321098765432109876543210
16232                                     xx111100x1xxxxxxxxxxx1xxxxxxxxxx
16233                                     ldr.  */
16234                                  return 873;
16235                                }
16236                            }
16237                        }
16238                    }
16239                  else
16240                    {
16241                      if (((word >> 22) & 0x1) == 0)
16242                        {
16243                          /* 33222222222211111111110000000000
16244                             10987654321098765432109876543210
16245                             xxx11101x0xxxxxxxxxxxxxxxxxxxxxx
16246                             str.  */
16247                          return 891;
16248                        }
16249                      else
16250                        {
16251                          /* 33222222222211111111110000000000
16252                             10987654321098765432109876543210
16253                             xxx11101x1xxxxxxxxxxxxxxxxxxxxxx
16254                             ldr.  */
16255                          return 892;
16256                        }
16257                    }
16258                }
16259            }
16260          else
16261            {
16262              if (((word >> 24) & 0x1) == 0)
16263                {
16264                  if (((word >> 21) & 0x1) == 0)
16265                    {
16266                      if (((word >> 28) & 0x1) == 0)
16267                        {
16268                          if (((word >> 29) & 0x1) == 0)
16269                            {
16270                              if (((word >> 31) & 0x1) == 0)
16271                                {
16272                                  if (((word >> 10) & 0x1) == 0)
16273                                    {
16274                                      if (((word >> 11) & 0x1) == 0)
16275                                        {
16276                                          if (((word >> 12) & 0x1) == 0)
16277                                            {
16278                                              /* 33222222222211111111110000000000
16279                                                 10987654321098765432109876543210
16280                                                 0x001110xx0xxxxxxxx000xxxxxxxxxx
16281                                                 tbl.  */
16282                                              return 420;
16283                                            }
16284                                          else
16285                                            {
16286                                              /* 33222222222211111111110000000000
16287                                                 10987654321098765432109876543210
16288                                                 0x001110xx0xxxxxxxx100xxxxxxxxxx
16289                                                 tbx.  */
16290                                              return 421;
16291                                            }
16292                                        }
16293                                      else
16294                                        {
16295                                          if (((word >> 12) & 0x1) == 0)
16296                                            {
16297                                              if (((word >> 14) & 0x1) == 0)
16298                                                {
16299                                                  /* 33222222222211111111110000000000
16300                                                     10987654321098765432109876543210
16301                                                     0x001110xx0xxxxxx0x010xxxxxxxxxx
16302                                                     trn1.  */
16303                                                  return 263;
16304                                                }
16305                                              else
16306                                                {
16307                                                  /* 33222222222211111111110000000000
16308                                                     10987654321098765432109876543210
16309                                                     0x001110xx0xxxxxx1x010xxxxxxxxxx
16310                                                     trn2.  */
16311                                                  return 266;
16312                                                }
16313                                            }
16314                                          else
16315                                            {
16316                                              if (((word >> 13) & 0x1) == 0)
16317                                                {
16318                                                  if (((word >> 14) & 0x1) == 0)
16319                                                    {
16320                                                      /* 33222222222211111111110000000000
16321                                                         10987654321098765432109876543210
16322                                                         0x001110xx0xxxxxx00110xxxxxxxxxx
16323                                                         uzp1.  */
16324                                                      return 262;
16325                                                    }
16326                                                  else
16327                                                    {
16328                                                      /* 33222222222211111111110000000000
16329                                                         10987654321098765432109876543210
16330                                                         0x001110xx0xxxxxx10110xxxxxxxxxx
16331                                                         uzp2.  */
16332                                                      return 265;
16333                                                    }
16334                                                }
16335                                              else
16336                                                {
16337                                                  if (((word >> 14) & 0x1) == 0)
16338                                                    {
16339                                                      /* 33222222222211111111110000000000
16340                                                         10987654321098765432109876543210
16341                                                         0x001110xx0xxxxxx01110xxxxxxxxxx
16342                                                         zip1.  */
16343                                                      return 264;
16344                                                    }
16345                                                  else
16346                                                    {
16347                                                      /* 33222222222211111111110000000000
16348                                                         10987654321098765432109876543210
16349                                                         0x001110xx0xxxxxx11110xxxxxxxxxx
16350                                                         zip2.  */
16351                                                      return 267;
16352                                                    }
16353                                                }
16354                                            }
16355                                        }
16356                                    }
16357                                  else
16358                                    {
16359                                      if (((word >> 11) & 0x1) == 0)
16360                                        {
16361                                          if (((word >> 12) & 0x1) == 0)
16362                                            {
16363                                              if (((word >> 13) & 0x1) == 0)
16364                                                {
16365                                                  if (((word >> 22) & 0x1) == 0)
16366                                                    {
16367                                                      /* 33222222222211111111110000000000
16368                                                         10987654321098765432109876543210
16369                                                         0x001110x00xxxxxxx0001xxxxxxxxxx
16370                                                         dup.  */
16371                                                      return 149;
16372                                                    }
16373                                                  else
16374                                                    {
16375                                                      if (((word >> 23) & 0x1) == 0)
16376                                                        {
16377                                                          /* 33222222222211111111110000000000
16378                                                             10987654321098765432109876543210
16379                                                             0x001110010xxxxxxx0001xxxxxxxxxx
16380                                                             fmaxnm.  */
16381                                                          return 292;
16382                                                        }
16383                                                      else
16384                                                        {
16385                                                          /* 33222222222211111111110000000000
16386                                                             10987654321098765432109876543210
16387                                                             0x001110110xxxxxxx0001xxxxxxxxxx
16388                                                             fminnm.  */
16389                                                          return 308;
16390                                                        }
16391                                                    }
16392                                                }
16393                                              else
16394                                                {
16395                                                  if (((word >> 15) & 0x1) == 0)
16396                                                    {
16397                                                      /* 33222222222211111111110000000000
16398                                                         10987654321098765432109876543210
16399                                                         0x001110xx0xxxxx0x1001xxxxxxxxxx
16400                                                         fcmeq.  */
16401                                                      return 300;
16402                                                    }
16403                                                  else
16404                                                    {
16405                                                      /* 33222222222211111111110000000000
16406                                                         10987654321098765432109876543210
16407                                                         0x001110xx0xxxxx1x1001xxxxxxxxxx
16408                                                         smmla.  */
16409                                                      return 2413;
16410                                                    }
16411                                                }
16412                                            }
16413                                          else
16414                                            {
16415                                              if (((word >> 13) & 0x1) == 0)
16416                                                {
16417                                                  if (((word >> 15) & 0x1) == 0)
16418                                                    {
16419                                                      if (((word >> 23) & 0x1) == 0)
16420                                                        {
16421                                                          /* 33222222222211111111110000000000
16422                                                             10987654321098765432109876543210
16423                                                             0x0011100x0xxxxx0x0101xxxxxxxxxx
16424                                                             fadd.  */
16425                                                          return 296;
16426                                                        }
16427                                                      else
16428                                                        {
16429                                                          /* 33222222222211111111110000000000
16430                                                             10987654321098765432109876543210
16431                                                             0x0011101x0xxxxx0x0101xxxxxxxxxx
16432                                                             fsub.  */
16433                                                          return 312;
16434                                                        }
16435                                                    }
16436                                                  else
16437                                                    {
16438                                                      /* 33222222222211111111110000000000
16439                                                         10987654321098765432109876543210
16440                                                         0x001110xx0xxxxx1x0101xxxxxxxxxx
16441                                                         sdot.  */
16442                                                      return 2338;
16443                                                    }
16444                                                }
16445                                              else
16446                                                {
16447                                                  if (((word >> 23) & 0x1) == 0)
16448                                                    {
16449                                                      /* 33222222222211111111110000000000
16450                                                         10987654321098765432109876543210
16451                                                         0x0011100x0xxxxxxx1101xxxxxxxxxx
16452                                                         fmax.  */
16453                                                      return 302;
16454                                                    }
16455                                                  else
16456                                                    {
16457                                                      /* 33222222222211111111110000000000
16458                                                         10987654321098765432109876543210
16459                                                         0x0011101x0xxxxxxx1101xxxxxxxxxx
16460                                                         fmin.  */
16461                                                      return 314;
16462                                                    }
16463                                                }
16464                                            }
16465                                        }
16466                                      else
16467                                        {
16468                                          if (((word >> 12) & 0x1) == 0)
16469                                            {
16470                                              if (((word >> 13) & 0x1) == 0)
16471                                                {
16472                                                  if (((word >> 22) & 0x1) == 0)
16473                                                    {
16474                                                      /* 33222222222211111111110000000000
16475                                                         10987654321098765432109876543210
16476                                                         0x001110x00xxxxxxx0011xxxxxxxxxx
16477                                                         dup.  */
16478                                                      return 150;
16479                                                    }
16480                                                  else
16481                                                    {
16482                                                      if (((word >> 23) & 0x1) == 0)
16483                                                        {
16484                                                          /* 33222222222211111111110000000000
16485                                                             10987654321098765432109876543210
16486                                                             0x001110010xxxxxxx0011xxxxxxxxxx
16487                                                             fmla.  */
16488                                                          return 294;
16489                                                        }
16490                                                      else
16491                                                        {
16492                                                          /* 33222222222211111111110000000000
16493                                                             10987654321098765432109876543210
16494                                                             0x001110110xxxxxxx0011xxxxxxxxxx
16495                                                             fmls.  */
16496                                                          return 310;
16497                                                        }
16498                                                    }
16499                                                }
16500                                              else
16501                                                {
16502                                                  if (((word >> 15) & 0x1) == 0)
16503                                                    {
16504                                                      /* 33222222222211111111110000000000
16505                                                         10987654321098765432109876543210
16506                                                         0x001110xx0xxxxx0x1011xxxxxxxxxx
16507                                                         smov.  */
16508                                                      return 151;
16509                                                    }
16510                                                  else
16511                                                    {
16512                                                      /* 33222222222211111111110000000000
16513                                                         10987654321098765432109876543210
16514                                                         0x001110xx0xxxxx1x1011xxxxxxxxxx
16515                                                         usmmla.  */
16516                                                      return 2415;
16517                                                    }
16518                                                }
16519                                            }
16520                                          else
16521                                            {
16522                                              if (((word >> 13) & 0x1) == 0)
16523                                                {
16524                                                  if (((word >> 15) & 0x1) == 0)
16525                                                    {
16526                                                      if (((word >> 22) & 0x1) == 0)
16527                                                        {
16528                                                          /* 33222222222211111111110000000000
16529                                                             10987654321098765432109876543210
16530                                                             0x001110x00xxxxx0x0111xxxxxxxxxx
16531                                                             ins.  */
16532                                                          return 154;
16533                                                        }
16534                                                      else
16535                                                        {
16536                                                          /* 33222222222211111111110000000000
16537                                                             10987654321098765432109876543210
16538                                                             0x001110x10xxxxx0x0111xxxxxxxxxx
16539                                                             fmulx.  */
16540                                                          return 298;
16541                                                        }
16542                                                    }
16543                                                  else
16544                                                    {
16545                                                      /* 33222222222211111111110000000000
16546                                                         10987654321098765432109876543210
16547                                                         0x001110xx0xxxxx1x0111xxxxxxxxxx
16548                                                         usdot.  */
16549                                                      return 2416;
16550                                                    }
16551                                                }
16552                                              else
16553                                                {
16554                                                  if (((word >> 22) & 0x1) == 0)
16555                                                    {
16556                                                      /* 33222222222211111111110000000000
16557                                                         10987654321098765432109876543210
16558                                                         0x001110x00xxxxxxx1111xxxxxxxxxx
16559                                                         umov.  */
16560                                                      return 152;
16561                                                    }
16562                                                  else
16563                                                    {
16564                                                      if (((word >> 23) & 0x1) == 0)
16565                                                        {
16566                                                          /* 33222222222211111111110000000000
16567                                                             10987654321098765432109876543210
16568                                                             0x001110010xxxxxxx1111xxxxxxxxxx
16569                                                             frecps.  */
16570                                                          return 304;
16571                                                        }
16572                                                      else
16573                                                        {
16574                                                          /* 33222222222211111111110000000000
16575                                                             10987654321098765432109876543210
16576                                                             0x001110110xxxxxxx1111xxxxxxxxxx
16577                                                             frsqrts.  */
16578                                                          return 316;
16579                                                        }
16580                                                    }
16581                                                }
16582                                            }
16583                                        }
16584                                    }
16585                                }
16586                              else
16587                                {
16588                                  if (((word >> 22) & 0x1) == 0)
16589                                    {
16590                                      if (((word >> 23) & 0x1) == 0)
16591                                        {
16592                                          /* 33222222222211111111110000000000
16593                                             10987654321098765432109876543210
16594                                             1x001110000xxxxxxxxxxxxxxxxxxxxx
16595                                             eor3.  */
16596                                          return 2345;
16597                                        }
16598                                      else
16599                                        {
16600                                          /* 33222222222211111111110000000000
16601                                             10987654321098765432109876543210
16602                                             1x001110100xxxxxxxxxxxxxxxxxxxxx
16603                                             xar.  */
16604                                          return 2347;
16605                                        }
16606                                    }
16607                                  else
16608                                    {
16609                                      if (((word >> 15) & 0x1) == 0)
16610                                        {
16611                                          /* 33222222222211111111110000000000
16612                                             10987654321098765432109876543210
16613                                             1x001110x10xxxxx0xxxxxxxxxxxxxxx
16614                                             sm3ss1.  */
16615                                          return 2349;
16616                                        }
16617                                      else
16618                                        {
16619                                          if (((word >> 10) & 0x1) == 0)
16620                                            {
16621                                              if (((word >> 11) & 0x1) == 0)
16622                                                {
16623                                                  if (((word >> 23) & 0x1) == 0)
16624                                                    {
16625                                                      /* 33222222222211111111110000000000
16626                                                         10987654321098765432109876543210
16627                                                         1x001110010xxxxx1xxx00xxxxxxxxxx
16628                                                         sm3tt1a.  */
16629                                                      return 2350;
16630                                                    }
16631                                                  else
16632                                                    {
16633                                                      /* 33222222222211111111110000000000
16634                                                         10987654321098765432109876543210
16635                                                         1x001110110xxxxx1xxx00xxxxxxxxxx
16636                                                         sha512su0.  */
16637                                                      return 2343;
16638                                                    }
16639                                                }
16640                                              else
16641                                                {
16642                                                  /* 33222222222211111111110000000000
16643                                                     10987654321098765432109876543210
16644                                                     1x001110x10xxxxx1xxx10xxxxxxxxxx
16645                                                     sm3tt2a.  */
16646                                                  return 2352;
16647                                                }
16648                                            }
16649                                          else
16650                                            {
16651                                              if (((word >> 11) & 0x1) == 0)
16652                                                {
16653                                                  if (((word >> 23) & 0x1) == 0)
16654                                                    {
16655                                                      /* 33222222222211111111110000000000
16656                                                         10987654321098765432109876543210
16657                                                         1x001110010xxxxx1xxx01xxxxxxxxxx
16658                                                         sm3tt1b.  */
16659                                                      return 2351;
16660                                                    }
16661                                                  else
16662                                                    {
16663                                                      /* 33222222222211111111110000000000
16664                                                         10987654321098765432109876543210
16665                                                         1x001110110xxxxx1xxx01xxxxxxxxxx
16666                                                         sm4e.  */
16667                                                      return 2356;
16668                                                    }
16669                                                }
16670                                              else
16671                                                {
16672                                                  /* 33222222222211111111110000000000
16673                                                     10987654321098765432109876543210
16674                                                     1x001110x10xxxxx1xxx11xxxxxxxxxx
16675                                                     sm3tt2b.  */
16676                                                  return 2353;
16677                                                }
16678                                            }
16679                                        }
16680                                    }
16681                                }
16682                            }
16683                          else
16684                            {
16685                              if (((word >> 10) & 0x1) == 0)
16686                                {
16687                                  /* 33222222222211111111110000000000
16688                                     10987654321098765432109876543210
16689                                     xx101110xx0xxxxxxxxxx0xxxxxxxxxx
16690                                     ext.  */
16691                                  return 132;
16692                                }
16693                              else
16694                                {
16695                                  if (((word >> 15) & 0x1) == 0)
16696                                    {
16697                                      if (((word >> 22) & 0x1) == 0)
16698                                        {
16699                                          /* 33222222222211111111110000000000
16700                                             10987654321098765432109876543210
16701                                             xx101110x00xxxxx0xxxx1xxxxxxxxxx
16702                                             ins.  */
16703                                          return 156;
16704                                        }
16705                                      else
16706                                        {
16707                                          if (((word >> 11) & 0x1) == 0)
16708                                            {
16709                                              if (((word >> 12) & 0x1) == 0)
16710                                                {
16711                                                  if (((word >> 13) & 0x1) == 0)
16712                                                    {
16713                                                      if (((word >> 23) & 0x1) == 0)
16714                                                        {
16715                                                          /* 33222222222211111111110000000000
16716                                                             10987654321098765432109876543210
16717                                                             xx101110010xxxxx0x0001xxxxxxxxxx
16718                                                             fmaxnmp.  */
16719                                                          return 343;
16720                                                        }
16721                                                      else
16722                                                        {
16723                                                          /* 33222222222211111111110000000000
16724                                                             10987654321098765432109876543210
16725                                                             xx101110110xxxxx0x0001xxxxxxxxxx
16726                                                             fminnmp.  */
16727                                                          return 359;
16728                                                        }
16729                                                    }
16730                                                  else
16731                                                    {
16732                                                      if (((word >> 23) & 0x1) == 0)
16733                                                        {
16734                                                          /* 33222222222211111111110000000000
16735                                                             10987654321098765432109876543210
16736                                                             xx101110010xxxxx0x1001xxxxxxxxxx
16737                                                             fcmge.  */
16738                                                          return 349;
16739                                                        }
16740                                                      else
16741                                                        {
16742                                                          /* 33222222222211111111110000000000
16743                                                             10987654321098765432109876543210
16744                                                             xx101110110xxxxx0x1001xxxxxxxxxx
16745                                                             fcmgt.  */
16746                                                          return 363;
16747                                                        }
16748                                                    }
16749                                                }
16750                                              else
16751                                                {
16752                                                  if (((word >> 13) & 0x1) == 0)
16753                                                    {
16754                                                      if (((word >> 23) & 0x1) == 0)
16755                                                        {
16756                                                          /* 33222222222211111111110000000000
16757                                                             10987654321098765432109876543210
16758                                                             xx101110010xxxxx0x0101xxxxxxxxxx
16759                                                             faddp.  */
16760                                                          return 345;
16761                                                        }
16762                                                      else
16763                                                        {
16764                                                          /* 33222222222211111111110000000000
16765                                                             10987654321098765432109876543210
16766                                                             xx101110110xxxxx0x0101xxxxxxxxxx
16767                                                             fabd.  */
16768                                                          return 361;
16769                                                        }
16770                                                    }
16771                                                  else
16772                                                    {
16773                                                      if (((word >> 23) & 0x1) == 0)
16774                                                        {
16775                                                          /* 33222222222211111111110000000000
16776                                                             10987654321098765432109876543210
16777                                                             xx101110010xxxxx0x1101xxxxxxxxxx
16778                                                             fmaxp.  */
16779                                                          return 353;
16780                                                        }
16781                                                      else
16782                                                        {
16783                                                          /* 33222222222211111111110000000000
16784                                                             10987654321098765432109876543210
16785                                                             xx101110110xxxxx0x1101xxxxxxxxxx
16786                                                             fminp.  */
16787                                                          return 367;
16788                                                        }
16789                                                    }
16790                                                }
16791                                            }
16792                                          else
16793                                            {
16794                                              if (((word >> 12) & 0x1) == 0)
16795                                                {
16796                                                  if (((word >> 23) & 0x1) == 0)
16797                                                    {
16798                                                      /* 33222222222211111111110000000000
16799                                                         10987654321098765432109876543210
16800                                                         xx101110010xxxxx0xx011xxxxxxxxxx
16801                                                         facge.  */
16802                                                      return 351;
16803                                                    }
16804                                                  else
16805                                                    {
16806                                                      /* 33222222222211111111110000000000
16807                                                         10987654321098765432109876543210
16808                                                         xx101110110xxxxx0xx011xxxxxxxxxx
16809                                                         facgt.  */
16810                                                      return 365;
16811                                                    }
16812                                                }
16813                                              else
16814                                                {
16815                                                  if (((word >> 13) & 0x1) == 0)
16816                                                    {
16817                                                      /* 33222222222211111111110000000000
16818                                                         10987654321098765432109876543210
16819                                                         xx101110x10xxxxx0x0111xxxxxxxxxx
16820                                                         fmul.  */
16821                                                      return 347;
16822                                                    }
16823                                                  else
16824                                                    {
16825                                                      /* 33222222222211111111110000000000
16826                                                         10987654321098765432109876543210
16827                                                         xx101110x10xxxxx0x1111xxxxxxxxxx
16828                                                         fdiv.  */
16829                                                      return 355;
16830                                                    }
16831                                                }
16832                                            }
16833                                        }
16834                                    }
16835                                  else
16836                                    {
16837                                      if (((word >> 13) & 0x1) == 0)
16838                                        {
16839                                          if (((word >> 14) & 0x1) == 0)
16840                                            {
16841                                              if (((word >> 11) & 0x1) == 0)
16842                                                {
16843                                                  if (((word >> 12) & 0x1) == 0)
16844                                                    {
16845                                                      /* 33222222222211111111110000000000
16846                                                         10987654321098765432109876543210
16847                                                         xx101110xx0xxxxx100001xxxxxxxxxx
16848                                                         sqrdmlah.  */
16849                                                      return 370;
16850                                                    }
16851                                                  else
16852                                                    {
16853                                                      /* 33222222222211111111110000000000
16854                                                         10987654321098765432109876543210
16855                                                         xx101110xx0xxxxx100101xxxxxxxxxx
16856                                                         udot.  */
16857                                                      return 2337;
16858                                                    }
16859                                                }
16860                                              else
16861                                                {
16862                                                  /* 33222222222211111111110000000000
16863                                                     10987654321098765432109876543210
16864                                                     xx101110xx0xxxxx100x11xxxxxxxxxx
16865                                                     sqrdmlsh.  */
16866                                                  return 371;
16867                                                }
16868                                            }
16869                                          else
16870                                            {
16871                                              /* 33222222222211111111110000000000
16872                                                 10987654321098765432109876543210
16873                                                 xx101110xx0xxxxx110xx1xxxxxxxxxx
16874                                                 fcmla.  */
16875                                              return 372;
16876                                            }
16877                                        }
16878                                      else
16879                                        {
16880                                          if (((word >> 11) & 0x1) == 0)
16881                                            {
16882                                              if (((word >> 14) & 0x1) == 0)
16883                                                {
16884                                                  /* 33222222222211111111110000000000
16885                                                     10987654321098765432109876543210
16886                                                     xx101110xx0xxxxx101x01xxxxxxxxxx
16887                                                     ummla.  */
16888                                                  return 2414;
16889                                                }
16890                                              else
16891                                                {
16892                                                  /* 33222222222211111111110000000000
16893                                                     10987654321098765432109876543210
16894                                                     xx101110xx0xxxxx111x01xxxxxxxxxx
16895                                                     fcadd.  */
16896                                                  return 373;
16897                                                }
16898                                            }
16899                                          else
16900                                            {
16901                                              if (((word >> 12) & 0x1) == 0)
16902                                                {
16903                                                  /* 33222222222211111111110000000000
16904                                                     10987654321098765432109876543210
16905                                                     xx101110xx0xxxxx1x1011xxxxxxxxxx
16906                                                     bfmmla.  */
16907                                                  return 2430;
16908                                                }
16909                                              else
16910                                                {
16911                                                  if (((word >> 23) & 0x1) == 0)
16912                                                    {
16913                                                      /* 33222222222211111111110000000000
16914                                                         10987654321098765432109876543210
16915                                                         xx1011100x0xxxxx1x1111xxxxxxxxxx
16916                                                         bfdot.  */
16917                                                      return 2428;
16918                                                    }
16919                                                  else
16920                                                    {
16921                                                      if (((word >> 30) & 0x1) == 0)
16922                                                        {
16923                                                          /* 33222222222211111111110000000000
16924                                                             10987654321098765432109876543210
16925                                                             x01011101x0xxxxx1x1111xxxxxxxxxx
16926                                                             bfmlalb.  */
16927                                                          return 2435;
16928                                                        }
16929                                                      else
16930                                                        {
16931                                                          /* 33222222222211111111110000000000
16932                                                             10987654321098765432109876543210
16933                                                             x11011101x0xxxxx1x1111xxxxxxxxxx
16934                                                             bfmlalt.  */
16935                                                          return 2434;
16936                                                        }
16937                                                    }
16938                                                }
16939                                            }
16940                                        }
16941                                    }
16942                                }
16943                            }
16944                        }
16945                      else
16946                        {
16947                          if (((word >> 29) & 0x1) == 0)
16948                            {
16949                              if (((word >> 30) & 0x1) == 0)
16950                                {
16951                                  if (((word >> 16) & 0x1) == 0)
16952                                    {
16953                                      if (((word >> 17) & 0x1) == 0)
16954                                        {
16955                                          /* 33222222222211111111110000000000
16956                                             10987654321098765432109876543210
16957                                             x0011110xx0xxx00xxxxxxxxxxxxxxxx
16958                                             fcvtzs.  */
16959                                          return 763;
16960                                        }
16961                                      else
16962                                        {
16963                                          /* 33222222222211111111110000000000
16964                                             10987654321098765432109876543210
16965                                             x0011110xx0xxx10xxxxxxxxxxxxxxxx
16966                                             scvtf.  */
16967                                          return 759;
16968                                        }
16969                                    }
16970                                  else
16971                                    {
16972                                      if (((word >> 17) & 0x1) == 0)
16973                                        {
16974                                          /* 33222222222211111111110000000000
16975                                             10987654321098765432109876543210
16976                                             x0011110xx0xxx01xxxxxxxxxxxxxxxx
16977                                             fcvtzu.  */
16978                                          return 765;
16979                                        }
16980                                      else
16981                                        {
16982                                          /* 33222222222211111111110000000000
16983                                             10987654321098765432109876543210
16984                                             x0011110xx0xxx11xxxxxxxxxxxxxxxx
16985                                             ucvtf.  */
16986                                          return 761;
16987                                        }
16988                                    }
16989                                }
16990                              else
16991                                {
16992                                  if (((word >> 10) & 0x1) == 0)
16993                                    {
16994                                      if (((word >> 12) & 0x1) == 0)
16995                                        {
16996                                          if (((word >> 13) & 0x1) == 0)
16997                                            {
16998                                              if (((word >> 14) & 0x1) == 0)
16999                                                {
17000                                                  /* 33222222222211111111110000000000
17001                                                     10987654321098765432109876543210
17002                                                     x1011110xx0xxxxxx000x0xxxxxxxxxx
17003                                                     sha1c.  */
17004                                                  return 678;
17005                                                }
17006                                              else
17007                                                {
17008                                                  /* 33222222222211111111110000000000
17009                                                     10987654321098765432109876543210
17010                                                     x1011110xx0xxxxxx100x0xxxxxxxxxx
17011                                                     sha256h.  */
17012                                                  return 682;
17013                                                }
17014                                            }
17015                                          else
17016                                            {
17017                                              if (((word >> 14) & 0x1) == 0)
17018                                                {
17019                                                  /* 33222222222211111111110000000000
17020                                                     10987654321098765432109876543210
17021                                                     x1011110xx0xxxxxx010x0xxxxxxxxxx
17022                                                     sha1m.  */
17023                                                  return 680;
17024                                                }
17025                                              else
17026                                                {
17027                                                  /* 33222222222211111111110000000000
17028                                                     10987654321098765432109876543210
17029                                                     x1011110xx0xxxxxx110x0xxxxxxxxxx
17030                                                     sha256su1.  */
17031                                                  return 684;
17032                                                }
17033                                            }
17034                                        }
17035                                      else
17036                                        {
17037                                          if (((word >> 13) & 0x1) == 0)
17038                                            {
17039                                              if (((word >> 14) & 0x1) == 0)
17040                                                {
17041                                                  /* 33222222222211111111110000000000
17042                                                     10987654321098765432109876543210
17043                                                     x1011110xx0xxxxxx001x0xxxxxxxxxx
17044                                                     sha1p.  */
17045                                                  return 679;
17046                                                }
17047                                              else
17048                                                {
17049                                                  /* 33222222222211111111110000000000
17050                                                     10987654321098765432109876543210
17051                                                     x1011110xx0xxxxxx101x0xxxxxxxxxx
17052                                                     sha256h2.  */
17053                                                  return 683;
17054                                                }
17055                                            }
17056                                          else
17057                                            {
17058                                              /* 33222222222211111111110000000000
17059                                                 10987654321098765432109876543210
17060                                                 x1011110xx0xxxxxxx11x0xxxxxxxxxx
17061                                                 sha1su0.  */
17062                                              return 681;
17063                                            }
17064                                        }
17065                                    }
17066                                  else
17067                                    {
17068                                      if (((word >> 11) & 0x1) == 0)
17069                                        {
17070                                          if (((word >> 13) & 0x1) == 0)
17071                                            {
17072                                              /* 33222222222211111111110000000000
17073                                                 10987654321098765432109876543210
17074                                                 x1011110xx0xxxxxxx0x01xxxxxxxxxx
17075                                                 dup.  */
17076                                              return 535;
17077                                            }
17078                                          else
17079                                            {
17080                                              /* 33222222222211111111110000000000
17081                                                 10987654321098765432109876543210
17082                                                 x1011110xx0xxxxxxx1x01xxxxxxxxxx
17083                                                 fcmeq.  */
17084                                              return 556;
17085                                            }
17086                                        }
17087                                      else
17088                                        {
17089                                          if (((word >> 13) & 0x1) == 0)
17090                                            {
17091                                              /* 33222222222211111111110000000000
17092                                                 10987654321098765432109876543210
17093                                                 x1011110xx0xxxxxxx0x11xxxxxxxxxx
17094                                                 fmulx.  */
17095                                              return 554;
17096                                            }
17097                                          else
17098                                            {
17099                                              if (((word >> 23) & 0x1) == 0)
17100                                                {
17101                                                  /* 33222222222211111111110000000000
17102                                                     10987654321098765432109876543210
17103                                                     x10111100x0xxxxxxx1x11xxxxxxxxxx
17104                                                     frecps.  */
17105                                                  return 558;
17106                                                }
17107                                              else
17108                                                {
17109                                                  /* 33222222222211111111110000000000
17110                                                     10987654321098765432109876543210
17111                                                     x10111101x0xxxxxxx1x11xxxxxxxxxx
17112                                                     frsqrts.  */
17113                                                  return 560;
17114                                                }
17115                                            }
17116                                        }
17117                                    }
17118                                }
17119                            }
17120                          else
17121                            {
17122                              if (((word >> 11) & 0x1) == 0)
17123                                {
17124                                  if (((word >> 12) & 0x1) == 0)
17125                                    {
17126                                      if (((word >> 13) & 0x1) == 0)
17127                                        {
17128                                          /* 33222222222211111111110000000000
17129                                             10987654321098765432109876543210
17130                                             xx111110xx0xxxxxxx000xxxxxxxxxxx
17131                                             sqrdmlah.  */
17132                                          return 588;
17133                                        }
17134                                      else
17135                                        {
17136                                          if (((word >> 23) & 0x1) == 0)
17137                                            {
17138                                              /* 33222222222211111111110000000000
17139                                                 10987654321098765432109876543210
17140                                                 xx1111100x0xxxxxxx100xxxxxxxxxxx
17141                                                 fcmge.  */
17142                                              return 573;
17143                                            }
17144                                          else
17145                                            {
17146                                              /* 33222222222211111111110000000000
17147                                                 10987654321098765432109876543210
17148                                                 xx1111101x0xxxxxxx100xxxxxxxxxxx
17149                                                 fcmgt.  */
17150                                              return 579;
17151                                            }
17152                                        }
17153                                    }
17154                                  else
17155                                    {
17156                                      /* 33222222222211111111110000000000
17157                                         10987654321098765432109876543210
17158                                         xx111110xx0xxxxxxxx10xxxxxxxxxxx
17159                                         fabd.  */
17160                                      return 577;
17161                                    }
17162                                }
17163                              else
17164                                {
17165                                  if (((word >> 13) & 0x1) == 0)
17166                                    {
17167                                      /* 33222222222211111111110000000000
17168                                         10987654321098765432109876543210
17169                                         xx111110xx0xxxxxxx0x1xxxxxxxxxxx
17170                                         sqrdmlsh.  */
17171                                      return 589;
17172                                    }
17173                                  else
17174                                    {
17175                                      if (((word >> 23) & 0x1) == 0)
17176                                        {
17177                                          /* 33222222222211111111110000000000
17178                                             10987654321098765432109876543210
17179                                             xx1111100x0xxxxxxx1x1xxxxxxxxxxx
17180                                             facge.  */
17181                                          return 575;
17182                                        }
17183                                      else
17184                                        {
17185                                          /* 33222222222211111111110000000000
17186                                             10987654321098765432109876543210
17187                                             xx1111101x0xxxxxxx1x1xxxxxxxxxxx
17188                                             facgt.  */
17189                                          return 581;
17190                                        }
17191                                    }
17192                                }
17193                            }
17194                        }
17195                    }
17196                  else
17197                    {
17198                      if (((word >> 28) & 0x1) == 0)
17199                        {
17200                          if (((word >> 15) & 0x1) == 0)
17201                            {
17202                              if (((word >> 29) & 0x1) == 0)
17203                                {
17204                                  if (((word >> 31) & 0x1) == 0)
17205                                    {
17206                                      if (((word >> 10) & 0x1) == 0)
17207                                        {
17208                                          if (((word >> 11) & 0x1) == 0)
17209                                            {
17210                                              if (((word >> 12) & 0x1) == 0)
17211                                                {
17212                                                  if (((word >> 13) & 0x1) == 0)
17213                                                    {
17214                                                      if (((word >> 14) & 0x1) == 0)
17215                                                        {
17216                                                          if (((word >> 30) & 0x1) == 0)
17217                                                            {
17218                                                              /* 33222222222211111111110000000000
17219                                                                 10987654321098765432109876543210
17220                                                                 00001110xx1xxxxx000000xxxxxxxxxx
17221                                                                 saddl.  */
17222                                                              return 44;
17223                                                            }
17224                                                          else
17225                                                            {
17226                                                              /* 33222222222211111111110000000000
17227                                                                 10987654321098765432109876543210
17228                                                                 01001110xx1xxxxx000000xxxxxxxxxx
17229                                                                 saddl2.  */
17230                                                              return 45;
17231                                                            }
17232                                                        }
17233                                                      else
17234                                                        {
17235                                                          if (((word >> 30) & 0x1) == 0)
17236                                                            {
17237                                                              /* 33222222222211111111110000000000
17238                                                                 10987654321098765432109876543210
17239                                                                 00001110xx1xxxxx010000xxxxxxxxxx
17240                                                                 addhn.  */
17241                                                              return 52;
17242                                                            }
17243                                                          else
17244                                                            {
17245                                                              /* 33222222222211111111110000000000
17246                                                                 10987654321098765432109876543210
17247                                                                 01001110xx1xxxxx010000xxxxxxxxxx
17248                                                                 addhn2.  */
17249                                                              return 53;
17250                                                            }
17251                                                        }
17252                                                    }
17253                                                  else
17254                                                    {
17255                                                      if (((word >> 14) & 0x1) == 0)
17256                                                        {
17257                                                          if (((word >> 30) & 0x1) == 0)
17258                                                            {
17259                                                              /* 33222222222211111111110000000000
17260                                                                 10987654321098765432109876543210
17261                                                                 00001110xx1xxxxx001000xxxxxxxxxx
17262                                                                 ssubl.  */
17263                                                              return 48;
17264                                                            }
17265                                                          else
17266                                                            {
17267                                                              /* 33222222222211111111110000000000
17268                                                                 10987654321098765432109876543210
17269                                                                 01001110xx1xxxxx001000xxxxxxxxxx
17270                                                                 ssubl2.  */
17271                                                              return 49;
17272                                                            }
17273                                                        }
17274                                                      else
17275                                                        {
17276                                                          if (((word >> 30) & 0x1) == 0)
17277                                                            {
17278                                                              /* 33222222222211111111110000000000
17279                                                                 10987654321098765432109876543210
17280                                                                 00001110xx1xxxxx011000xxxxxxxxxx
17281                                                                 subhn.  */
17282                                                              return 56;
17283                                                            }
17284                                                          else
17285                                                            {
17286                                                              /* 33222222222211111111110000000000
17287                                                                 10987654321098765432109876543210
17288                                                                 01001110xx1xxxxx011000xxxxxxxxxx
17289                                                                 subhn2.  */
17290                                                              return 57;
17291                                                            }
17292                                                        }
17293                                                    }
17294                                                }
17295                                              else
17296                                                {
17297                                                  if (((word >> 13) & 0x1) == 0)
17298                                                    {
17299                                                      if (((word >> 14) & 0x1) == 0)
17300                                                        {
17301                                                          if (((word >> 30) & 0x1) == 0)
17302                                                            {
17303                                                              /* 33222222222211111111110000000000
17304                                                                 10987654321098765432109876543210
17305                                                                 00001110xx1xxxxx000100xxxxxxxxxx
17306                                                                 saddw.  */
17307                                                              return 46;
17308                                                            }
17309                                                          else
17310                                                            {
17311                                                              /* 33222222222211111111110000000000
17312                                                                 10987654321098765432109876543210
17313                                                                 01001110xx1xxxxx000100xxxxxxxxxx
17314                                                                 saddw2.  */
17315                                                              return 47;
17316                                                            }
17317                                                        }
17318                                                      else
17319                                                        {
17320                                                          if (((word >> 30) & 0x1) == 0)
17321                                                            {
17322                                                              /* 33222222222211111111110000000000
17323                                                                 10987654321098765432109876543210
17324                                                                 00001110xx1xxxxx010100xxxxxxxxxx
17325                                                                 sabal.  */
17326                                                              return 54;
17327                                                            }
17328                                                          else
17329                                                            {
17330                                                              /* 33222222222211111111110000000000
17331                                                                 10987654321098765432109876543210
17332                                                                 01001110xx1xxxxx010100xxxxxxxxxx
17333                                                                 sabal2.  */
17334                                                              return 55;
17335                                                            }
17336                                                        }
17337                                                    }
17338                                                  else
17339                                                    {
17340                                                      if (((word >> 14) & 0x1) == 0)
17341                                                        {
17342                                                          if (((word >> 30) & 0x1) == 0)
17343                                                            {
17344                                                              /* 33222222222211111111110000000000
17345                                                                 10987654321098765432109876543210
17346                                                                 00001110xx1xxxxx001100xxxxxxxxxx
17347                                                                 ssubw.  */
17348                                                              return 50;
17349                                                            }
17350                                                          else
17351                                                            {
17352                                                              /* 33222222222211111111110000000000
17353                                                                 10987654321098765432109876543210
17354                                                                 01001110xx1xxxxx001100xxxxxxxxxx
17355                                                                 ssubw2.  */
17356                                                              return 51;
17357                                                            }
17358                                                        }
17359                                                      else
17360                                                        {
17361                                                          if (((word >> 30) & 0x1) == 0)
17362                                                            {
17363                                                              /* 33222222222211111111110000000000
17364                                                                 10987654321098765432109876543210
17365                                                                 00001110xx1xxxxx011100xxxxxxxxxx
17366                                                                 sabdl.  */
17367                                                              return 58;
17368                                                            }
17369                                                          else
17370                                                            {
17371                                                              /* 33222222222211111111110000000000
17372                                                                 10987654321098765432109876543210
17373                                                                 01001110xx1xxxxx011100xxxxxxxxxx
17374                                                                 sabdl2.  */
17375                                                              return 59;
17376                                                            }
17377                                                        }
17378                                                    }
17379                                                }
17380                                            }
17381                                          else
17382                                            {
17383                                              if (((word >> 12) & 0x1) == 0)
17384                                                {
17385                                                  if (((word >> 13) & 0x1) == 0)
17386                                                    {
17387                                                      if (((word >> 14) & 0x1) == 0)
17388                                                        {
17389                                                          /* 33222222222211111111110000000000
17390                                                             10987654321098765432109876543210
17391                                                             0x001110xx1xxxxx000010xxxxxxxxxx
17392                                                             rev64.  */
17393                                                          return 162;
17394                                                        }
17395                                                      else
17396                                                        {
17397                                                          if (((word >> 16) & 0x1) == 0)
17398                                                            {
17399                                                              if (((word >> 19) & 0x1) == 0)
17400                                                                {
17401                                                                  /* 33222222222211111111110000000000
17402                                                                     10987654321098765432109876543210
17403                                                                     0x001110xx1x0xx0010010xxxxxxxxxx
17404                                                                     cls.  */
17405                                                                  return 166;
17406                                                                }
17407                                                              else
17408                                                                {
17409                                                                  /* 33222222222211111111110000000000
17410                                                                     10987654321098765432109876543210
17411                                                                     0x001110xx1x1xx0010010xxxxxxxxxx
17412                                                                     aese.  */
17413                                                                  return 671;
17414                                                                }
17415                                                            }
17416                                                          else
17417                                                            {
17418                                                              if (((word >> 30) & 0x1) == 0)
17419                                                                {
17420                                                                  /* 33222222222211111111110000000000
17421                                                                     10987654321098765432109876543210
17422                                                                     00001110xx1xxxx1010010xxxxxxxxxx
17423                                                                     sqxtn.  */
17424                                                                  return 176;
17425                                                                }
17426                                                              else
17427                                                                {
17428                                                                  /* 33222222222211111111110000000000
17429                                                                     10987654321098765432109876543210
17430                                                                     01001110xx1xxxx1010010xxxxxxxxxx
17431                                                                     sqxtn2.  */
17432                                                                  return 177;
17433                                                                }
17434                                                            }
17435                                                        }
17436                                                    }
17437                                                  else
17438                                                    {
17439                                                      if (((word >> 14) & 0x1) == 0)
17440                                                        {
17441                                                          if (((word >> 16) & 0x1) == 0)
17442                                                            {
17443                                                              /* 33222222222211111111110000000000
17444                                                                 10987654321098765432109876543210
17445                                                                 0x001110xx1xxxx0001010xxxxxxxxxx
17446                                                                 saddlp.  */
17447                                                              return 164;
17448                                                            }
17449                                                          else
17450                                                            {
17451                                                              if (((word >> 30) & 0x1) == 0)
17452                                                                {
17453                                                                  /* 33222222222211111111110000000000
17454                                                                     10987654321098765432109876543210
17455                                                                     00001110xx1xxxx1001010xxxxxxxxxx
17456                                                                     xtn.  */
17457                                                                  return 174;
17458                                                                }
17459                                                              else
17460                                                                {
17461                                                                  /* 33222222222211111111110000000000
17462                                                                     10987654321098765432109876543210
17463                                                                     01001110xx1xxxx1001010xxxxxxxxxx
17464                                                                     xtn2.  */
17465                                                                  return 175;
17466                                                                }
17467                                                            }
17468                                                        }
17469                                                      else
17470                                                        {
17471                                                          if (((word >> 16) & 0x1) == 0)
17472                                                            {
17473                                                              if (((word >> 19) & 0x1) == 0)
17474                                                                {
17475                                                                  /* 33222222222211111111110000000000
17476                                                                     10987654321098765432109876543210
17477                                                                     0x001110xx1x0xx0011010xxxxxxxxxx
17478                                                                     sadalp.  */
17479                                                                  return 168;
17480                                                                }
17481                                                              else
17482                                                                {
17483                                                                  /* 33222222222211111111110000000000
17484                                                                     10987654321098765432109876543210
17485                                                                     0x001110xx1x1xx0011010xxxxxxxxxx
17486                                                                     aesmc.  */
17487                                                                  return 673;
17488                                                                }
17489                                                            }
17490                                                          else
17491                                                            {
17492                                                              if (((word >> 23) & 0x1) == 0)
17493                                                                {
17494                                                                  if (((word >> 30) & 0x1) == 0)
17495                                                                    {
17496                                                                      /* 33222222222211111111110000000000
17497                                                                         10987654321098765432109876543210
17498                                                                         000011100x1xxxx1011010xxxxxxxxxx
17499                                                                         fcvtn.  */
17500                                                                      return 178;
17501                                                                    }
17502                                                                  else
17503                                                                    {
17504                                                                      /* 33222222222211111111110000000000
17505                                                                         10987654321098765432109876543210
17506                                                                         010011100x1xxxx1011010xxxxxxxxxx
17507                                                                         fcvtn2.  */
17508                                                                      return 179;
17509                                                                    }
17510                                                                }
17511                                                              else
17512                                                                {
17513                                                                  if (((word >> 30) & 0x1) == 0)
17514                                                                    {
17515                                                                      /* 33222222222211111111110000000000
17516                                                                         10987654321098765432109876543210
17517                                                                         000011101x1xxxx1011010xxxxxxxxxx
17518                                                                         bfcvtn.  */
17519                                                                      return 2431;
17520                                                                    }
17521                                                                  else
17522                                                                    {
17523                                                                      /* 33222222222211111111110000000000
17524                                                                         10987654321098765432109876543210
17525                                                                         010011101x1xxxx1011010xxxxxxxxxx
17526                                                                         bfcvtn2.  */
17527                                                                      return 2432;
17528                                                                    }
17529                                                                }
17530                                                            }
17531                                                        }
17532                                                    }
17533                                                }
17534                                              else
17535                                                {
17536                                                  if (((word >> 13) & 0x1) == 0)
17537                                                    {
17538                                                      if (((word >> 14) & 0x1) == 0)
17539                                                        {
17540                                                          /* 33222222222211111111110000000000
17541                                                             10987654321098765432109876543210
17542                                                             0x001110xx1xxxxx000110xxxxxxxxxx
17543                                                             rev16.  */
17544                                                          return 163;
17545                                                        }
17546                                                      else
17547                                                        {
17548                                                          if (((word >> 19) & 0x1) == 0)
17549                                                            {
17550                                                              /* 33222222222211111111110000000000
17551                                                                 10987654321098765432109876543210
17552                                                                 0x001110xx1x0xxx010110xxxxxxxxxx
17553                                                                 cnt.  */
17554                                                              return 167;
17555                                                            }
17556                                                          else
17557                                                            {
17558                                                              /* 33222222222211111111110000000000
17559                                                                 10987654321098765432109876543210
17560                                                                 0x001110xx1x1xxx010110xxxxxxxxxx
17561                                                                 aesd.  */
17562                                                              return 672;
17563                                                            }
17564                                                        }
17565                                                    }
17566                                                  else
17567                                                    {
17568                                                      if (((word >> 14) & 0x1) == 0)
17569                                                        {
17570                                                          if (((word >> 20) & 0x1) == 0)
17571                                                            {
17572                                                              /* 33222222222211111111110000000000
17573                                                                 10987654321098765432109876543210
17574                                                                 0x001110xx10xxxx001110xxxxxxxxxx
17575                                                                 suqadd.  */
17576                                                              return 165;
17577                                                            }
17578                                                          else
17579                                                            {
17580                                                              /* 33222222222211111111110000000000
17581                                                                 10987654321098765432109876543210
17582                                                                 0x001110xx11xxxx001110xxxxxxxxxx
17583                                                                 saddlv.  */
17584                                                              return 29;
17585                                                            }
17586                                                        }
17587                                                      else
17588                                                        {
17589                                                          if (((word >> 16) & 0x1) == 0)
17590                                                            {
17591                                                              if (((word >> 19) & 0x1) == 0)
17592                                                                {
17593                                                                  /* 33222222222211111111110000000000
17594                                                                     10987654321098765432109876543210
17595                                                                     0x001110xx1x0xx0011110xxxxxxxxxx
17596                                                                     sqabs.  */
17597                                                                  return 169;
17598                                                                }
17599                                                              else
17600                                                                {
17601                                                                  /* 33222222222211111111110000000000
17602                                                                     10987654321098765432109876543210
17603                                                                     0x001110xx1x1xx0011110xxxxxxxxxx
17604                                                                     aesimc.  */
17605                                                                  return 674;
17606                                                                }
17607                                                            }
17608                                                          else
17609                                                            {
17610                                                              if (((word >> 30) & 0x1) == 0)
17611                                                                {
17612                                                                  /* 33222222222211111111110000000000
17613                                                                     10987654321098765432109876543210
17614                                                                     00001110xx1xxxx1011110xxxxxxxxxx
17615                                                                     fcvtl.  */
17616                                                                  return 180;
17617                                                                }
17618                                                              else
17619                                                                {
17620                                                                  /* 33222222222211111111110000000000
17621                                                                     10987654321098765432109876543210
17622                                                                     01001110xx1xxxx1011110xxxxxxxxxx
17623                                                                     fcvtl2.  */
17624                                                                  return 181;
17625                                                                }
17626                                                            }
17627                                                        }
17628                                                    }
17629                                                }
17630                                            }
17631                                        }
17632                                      else
17633                                        {
17634                                          if (((word >> 11) & 0x1) == 0)
17635                                            {
17636                                              if (((word >> 12) & 0x1) == 0)
17637                                                {
17638                                                  if (((word >> 13) & 0x1) == 0)
17639                                                    {
17640                                                      if (((word >> 14) & 0x1) == 0)
17641                                                        {
17642                                                          /* 33222222222211111111110000000000
17643                                                             10987654321098765432109876543210
17644                                                             0x001110xx1xxxxx000001xxxxxxxxxx
17645                                                             shadd.  */
17646                                                          return 268;
17647                                                        }
17648                                                      else
17649                                                        {
17650                                                          /* 33222222222211111111110000000000
17651                                                             10987654321098765432109876543210
17652                                                             0x001110xx1xxxxx010001xxxxxxxxxx
17653                                                             sshl.  */
17654                                                          return 275;
17655                                                        }
17656                                                    }
17657                                                  else
17658                                                    {
17659                                                      if (((word >> 14) & 0x1) == 0)
17660                                                        {
17661                                                          /* 33222222222211111111110000000000
17662                                                             10987654321098765432109876543210
17663                                                             0x001110xx1xxxxx001001xxxxxxxxxx
17664                                                             shsub.  */
17665                                                          return 271;
17666                                                        }
17667                                                      else
17668                                                        {
17669                                                          /* 33222222222211111111110000000000
17670                                                             10987654321098765432109876543210
17671                                                             0x001110xx1xxxxx011001xxxxxxxxxx
17672                                                             smax.  */
17673                                                          return 279;
17674                                                        }
17675                                                    }
17676                                                }
17677                                              else
17678                                                {
17679                                                  if (((word >> 13) & 0x1) == 0)
17680                                                    {
17681                                                      if (((word >> 14) & 0x1) == 0)
17682                                                        {
17683                                                          /* 33222222222211111111110000000000
17684                                                             10987654321098765432109876543210
17685                                                             0x001110xx1xxxxx000101xxxxxxxxxx
17686                                                             srhadd.  */
17687                                                          return 270;
17688                                                        }
17689                                                      else
17690                                                        {
17691                                                          /* 33222222222211111111110000000000
17692                                                             10987654321098765432109876543210
17693                                                             0x001110xx1xxxxx010101xxxxxxxxxx
17694                                                             srshl.  */
17695                                                          return 277;
17696                                                        }
17697                                                    }
17698                                                  else
17699                                                    {
17700                                                      if (((word >> 14) & 0x1) == 0)
17701                                                        {
17702                                                          /* 33222222222211111111110000000000
17703                                                             10987654321098765432109876543210
17704                                                             0x001110xx1xxxxx001101xxxxxxxxxx
17705                                                             cmgt.  */
17706                                                          return 273;
17707                                                        }
17708                                                      else
17709                                                        {
17710                                                          /* 33222222222211111111110000000000
17711                                                             10987654321098765432109876543210
17712                                                             0x001110xx1xxxxx011101xxxxxxxxxx
17713                                                             sabd.  */
17714                                                          return 281;
17715                                                        }
17716                                                    }
17717                                                }
17718                                            }
17719                                          else
17720                                            {
17721                                              if (((word >> 12) & 0x1) == 0)
17722                                                {
17723                                                  if (((word >> 13) & 0x1) == 0)
17724                                                    {
17725                                                      if (((word >> 14) & 0x1) == 0)
17726                                                        {
17727                                                          /* 33222222222211111111110000000000
17728                                                             10987654321098765432109876543210
17729                                                             0x001110xx1xxxxx000011xxxxxxxxxx
17730                                                             sqadd.  */
17731                                                          return 269;
17732                                                        }
17733                                                      else
17734                                                        {
17735                                                          /* 33222222222211111111110000000000
17736                                                             10987654321098765432109876543210
17737                                                             0x001110xx1xxxxx010011xxxxxxxxxx
17738                                                             sqshl.  */
17739                                                          return 276;
17740                                                        }
17741                                                    }
17742                                                  else
17743                                                    {
17744                                                      if (((word >> 14) & 0x1) == 0)
17745                                                        {
17746                                                          /* 33222222222211111111110000000000
17747                                                             10987654321098765432109876543210
17748                                                             0x001110xx1xxxxx001011xxxxxxxxxx
17749                                                             sqsub.  */
17750                                                          return 272;
17751                                                        }
17752                                                      else
17753                                                        {
17754                                                          /* 33222222222211111111110000000000
17755                                                             10987654321098765432109876543210
17756                                                             0x001110xx1xxxxx011011xxxxxxxxxx
17757                                                             smin.  */
17758                                                          return 280;
17759                                                        }
17760                                                    }
17761                                                }
17762                                              else
17763                                                {
17764                                                  if (((word >> 13) & 0x1) == 0)
17765                                                    {
17766                                                      if (((word >> 14) & 0x1) == 0)
17767                                                        {
17768                                                          if (((word >> 22) & 0x1) == 0)
17769                                                            {
17770                                                              if (((word >> 23) & 0x1) == 0)
17771                                                                {
17772                                                                  /* 33222222222211111111110000000000
17773                                                                     10987654321098765432109876543210
17774                                                                     0x001110001xxxxx000111xxxxxxxxxx
17775                                                                     and.  */
17776                                                                  return 305;
17777                                                                }
17778                                                              else
17779                                                                {
17780                                                                  /* 33222222222211111111110000000000
17781                                                                     10987654321098765432109876543210
17782                                                                     0x001110101xxxxx000111xxxxxxxxxx
17783                                                                     orr.  */
17784                                                                  return 317;
17785                                                                }
17786                                                            }
17787                                                          else
17788                                                            {
17789                                                              if (((word >> 23) & 0x1) == 0)
17790                                                                {
17791                                                                  /* 33222222222211111111110000000000
17792                                                                     10987654321098765432109876543210
17793                                                                     0x001110011xxxxx000111xxxxxxxxxx
17794                                                                     bic.  */
17795                                                                  return 306;
17796                                                                }
17797                                                              else
17798                                                                {
17799                                                                  /* 33222222222211111111110000000000
17800                                                                     10987654321098765432109876543210
17801                                                                     0x001110111xxxxx000111xxxxxxxxxx
17802                                                                     orn.  */
17803                                                                  return 319;
17804                                                                }
17805                                                            }
17806                                                        }
17807                                                      else
17808                                                        {
17809                                                          /* 33222222222211111111110000000000
17810                                                             10987654321098765432109876543210
17811                                                             0x001110xx1xxxxx010111xxxxxxxxxx
17812                                                             sqrshl.  */
17813                                                          return 278;
17814                                                        }
17815                                                    }
17816                                                  else
17817                                                    {
17818                                                      if (((word >> 14) & 0x1) == 0)
17819                                                        {
17820                                                          /* 33222222222211111111110000000000
17821                                                             10987654321098765432109876543210
17822                                                             0x001110xx1xxxxx001111xxxxxxxxxx
17823                                                             cmge.  */
17824                                                          return 274;
17825                                                        }
17826                                                      else
17827                                                        {
17828                                                          /* 33222222222211111111110000000000
17829                                                             10987654321098765432109876543210
17830                                                             0x001110xx1xxxxx011111xxxxxxxxxx
17831                                                             saba.  */
17832                                                          return 282;
17833                                                        }
17834                                                    }
17835                                                }
17836                                            }
17837                                        }
17838                                    }
17839                                  else
17840                                    {
17841                                      /* 33222222222211111111110000000000
17842                                         10987654321098765432109876543210
17843                                         1x001110xx1xxxxx0xxxxxxxxxxxxxxx
17844                                         bcax.  */
17845                                      return 2348;
17846                                    }
17847                                }
17848                              else
17849                                {
17850                                  if (((word >> 10) & 0x1) == 0)
17851                                    {
17852                                      if (((word >> 11) & 0x1) == 0)
17853                                        {
17854                                          if (((word >> 12) & 0x1) == 0)
17855                                            {
17856                                              if (((word >> 13) & 0x1) == 0)
17857                                                {
17858                                                  if (((word >> 14) & 0x1) == 0)
17859                                                    {
17860                                                      if (((word >> 30) & 0x1) == 0)
17861                                                        {
17862                                                          /* 33222222222211111111110000000000
17863                                                             10987654321098765432109876543210
17864                                                             x0101110xx1xxxxx000000xxxxxxxxxx
17865                                                             uaddl.  */
17866                                                          return 76;
17867                                                        }
17868                                                      else
17869                                                        {
17870                                                          /* 33222222222211111111110000000000
17871                                                             10987654321098765432109876543210
17872                                                             x1101110xx1xxxxx000000xxxxxxxxxx
17873                                                             uaddl2.  */
17874                                                          return 77;
17875                                                        }
17876                                                    }
17877                                                  else
17878                                                    {
17879                                                      if (((word >> 30) & 0x1) == 0)
17880                                                        {
17881                                                          /* 33222222222211111111110000000000
17882                                                             10987654321098765432109876543210
17883                                                             x0101110xx1xxxxx010000xxxxxxxxxx
17884                                                             raddhn.  */
17885                                                          return 84;
17886                                                        }
17887                                                      else
17888                                                        {
17889                                                          /* 33222222222211111111110000000000
17890                                                             10987654321098765432109876543210
17891                                                             x1101110xx1xxxxx010000xxxxxxxxxx
17892                                                             raddhn2.  */
17893                                                          return 85;
17894                                                        }
17895                                                    }
17896                                                }
17897                                              else
17898                                                {
17899                                                  if (((word >> 14) & 0x1) == 0)
17900                                                    {
17901                                                      if (((word >> 30) & 0x1) == 0)
17902                                                        {
17903                                                          /* 33222222222211111111110000000000
17904                                                             10987654321098765432109876543210
17905                                                             x0101110xx1xxxxx001000xxxxxxxxxx
17906                                                             usubl.  */
17907                                                          return 80;
17908                                                        }
17909                                                      else
17910                                                        {
17911                                                          /* 33222222222211111111110000000000
17912                                                             10987654321098765432109876543210
17913                                                             x1101110xx1xxxxx001000xxxxxxxxxx
17914                                                             usubl2.  */
17915                                                          return 81;
17916                                                        }
17917                                                    }
17918                                                  else
17919                                                    {
17920                                                      if (((word >> 30) & 0x1) == 0)
17921                                                        {
17922                                                          /* 33222222222211111111110000000000
17923                                                             10987654321098765432109876543210
17924                                                             x0101110xx1xxxxx011000xxxxxxxxxx
17925                                                             rsubhn.  */
17926                                                          return 88;
17927                                                        }
17928                                                      else
17929                                                        {
17930                                                          /* 33222222222211111111110000000000
17931                                                             10987654321098765432109876543210
17932                                                             x1101110xx1xxxxx011000xxxxxxxxxx
17933                                                             rsubhn2.  */
17934                                                          return 89;
17935                                                        }
17936                                                    }
17937                                                }
17938                                            }
17939                                          else
17940                                            {
17941                                              if (((word >> 13) & 0x1) == 0)
17942                                                {
17943                                                  if (((word >> 14) & 0x1) == 0)
17944                                                    {
17945                                                      if (((word >> 30) & 0x1) == 0)
17946                                                        {
17947                                                          /* 33222222222211111111110000000000
17948                                                             10987654321098765432109876543210
17949                                                             x0101110xx1xxxxx000100xxxxxxxxxx
17950                                                             uaddw.  */
17951                                                          return 78;
17952                                                        }
17953                                                      else
17954                                                        {
17955                                                          /* 33222222222211111111110000000000
17956                                                             10987654321098765432109876543210
17957                                                             x1101110xx1xxxxx000100xxxxxxxxxx
17958                                                             uaddw2.  */
17959                                                          return 79;
17960                                                        }
17961                                                    }
17962                                                  else
17963                                                    {
17964                                                      if (((word >> 30) & 0x1) == 0)
17965                                                        {
17966                                                          /* 33222222222211111111110000000000
17967                                                             10987654321098765432109876543210
17968                                                             x0101110xx1xxxxx010100xxxxxxxxxx
17969                                                             uabal.  */
17970                                                          return 86;
17971                                                        }
17972                                                      else
17973                                                        {
17974                                                          /* 33222222222211111111110000000000
17975                                                             10987654321098765432109876543210
17976                                                             x1101110xx1xxxxx010100xxxxxxxxxx
17977                                                             uabal2.  */
17978                                                          return 87;
17979                                                        }
17980                                                    }
17981                                                }
17982                                              else
17983                                                {
17984                                                  if (((word >> 14) & 0x1) == 0)
17985                                                    {
17986                                                      if (((word >> 30) & 0x1) == 0)
17987                                                        {
17988                                                          /* 33222222222211111111110000000000
17989                                                             10987654321098765432109876543210
17990                                                             x0101110xx1xxxxx001100xxxxxxxxxx
17991                                                             usubw.  */
17992                                                          return 82;
17993                                                        }
17994                                                      else
17995                                                        {
17996                                                          /* 33222222222211111111110000000000
17997                                                             10987654321098765432109876543210
17998                                                             x1101110xx1xxxxx001100xxxxxxxxxx
17999                                                             usubw2.  */
18000                                                          return 83;
18001                                                        }
18002                                                    }
18003                                                  else
18004                                                    {
18005                                                      if (((word >> 30) & 0x1) == 0)
18006                                                        {
18007                                                          /* 33222222222211111111110000000000
18008                                                             10987654321098765432109876543210
18009                                                             x0101110xx1xxxxx011100xxxxxxxxxx
18010                                                             uabdl.  */
18011                                                          return 90;
18012                                                        }
18013                                                      else
18014                                                        {
18015                                                          /* 33222222222211111111110000000000
18016                                                             10987654321098765432109876543210
18017                                                             x1101110xx1xxxxx011100xxxxxxxxxx
18018                                                             uabdl2.  */
18019                                                          return 91;
18020                                                        }
18021                                                    }
18022                                                }
18023                                            }
18024                                        }
18025                                      else
18026                                        {
18027                                          if (((word >> 12) & 0x1) == 0)
18028                                            {
18029                                              if (((word >> 13) & 0x1) == 0)
18030                                                {
18031                                                  if (((word >> 14) & 0x1) == 0)
18032                                                    {
18033                                                      /* 33222222222211111111110000000000
18034                                                         10987654321098765432109876543210
18035                                                         xx101110xx1xxxxx000010xxxxxxxxxx
18036                                                         rev32.  */
18037                                                      return 213;
18038                                                    }
18039                                                  else
18040                                                    {
18041                                                      if (((word >> 16) & 0x1) == 0)
18042                                                        {
18043                                                          /* 33222222222211111111110000000000
18044                                                             10987654321098765432109876543210
18045                                                             xx101110xx1xxxx0010010xxxxxxxxxx
18046                                                             clz.  */
18047                                                          return 216;
18048                                                        }
18049                                                      else
18050                                                        {
18051                                                          if (((word >> 30) & 0x1) == 0)
18052                                                            {
18053                                                              /* 33222222222211111111110000000000
18054                                                                 10987654321098765432109876543210
18055                                                                 x0101110xx1xxxx1010010xxxxxxxxxx
18056                                                                 uqxtn.  */
18057                                                              return 226;
18058                                                            }
18059                                                          else
18060                                                            {
18061                                                              /* 33222222222211111111110000000000
18062                                                                 10987654321098765432109876543210
18063                                                                 x1101110xx1xxxx1010010xxxxxxxxxx
18064                                                                 uqxtn2.  */
18065                                                              return 227;
18066                                                            }
18067                                                        }
18068                                                    }
18069                                                }
18070                                              else
18071                                                {
18072                                                  if (((word >> 14) & 0x1) == 0)
18073                                                    {
18074                                                      if (((word >> 16) & 0x1) == 0)
18075                                                        {
18076                                                          /* 33222222222211111111110000000000
18077                                                             10987654321098765432109876543210
18078                                                             xx101110xx1xxxx0001010xxxxxxxxxx
18079                                                             uaddlp.  */
18080                                                          return 214;
18081                                                        }
18082                                                      else
18083                                                        {
18084                                                          if (((word >> 30) & 0x1) == 0)
18085                                                            {
18086                                                              /* 33222222222211111111110000000000
18087                                                                 10987654321098765432109876543210
18088                                                                 x0101110xx1xxxx1001010xxxxxxxxxx
18089                                                                 sqxtun.  */
18090                                                              return 222;
18091                                                            }
18092                                                          else
18093                                                            {
18094                                                              /* 33222222222211111111110000000000
18095                                                                 10987654321098765432109876543210
18096                                                                 x1101110xx1xxxx1001010xxxxxxxxxx
18097                                                                 sqxtun2.  */
18098                                                              return 223;
18099                                                            }
18100                                                        }
18101                                                    }
18102                                                  else
18103                                                    {
18104                                                      if (((word >> 16) & 0x1) == 0)
18105                                                        {
18106                                                          /* 33222222222211111111110000000000
18107                                                             10987654321098765432109876543210
18108                                                             xx101110xx1xxxx0011010xxxxxxxxxx
18109                                                             uadalp.  */
18110                                                          return 217;
18111                                                        }
18112                                                      else
18113                                                        {
18114                                                          if (((word >> 30) & 0x1) == 0)
18115                                                            {
18116                                                              /* 33222222222211111111110000000000
18117                                                                 10987654321098765432109876543210
18118                                                                 x0101110xx1xxxx1011010xxxxxxxxxx
18119                                                                 fcvtxn.  */
18120                                                              return 228;
18121                                                            }
18122                                                          else
18123                                                            {
18124                                                              /* 33222222222211111111110000000000
18125                                                                 10987654321098765432109876543210
18126                                                                 x1101110xx1xxxx1011010xxxxxxxxxx
18127                                                                 fcvtxn2.  */
18128                                                              return 229;
18129                                                            }
18130                                                        }
18131                                                    }
18132                                                }
18133                                            }
18134                                          else
18135                                            {
18136                                              if (((word >> 13) & 0x1) == 0)
18137                                                {
18138                                                  if (((word >> 22) & 0x1) == 0)
18139                                                    {
18140                                                      /* 33222222222211111111110000000000
18141                                                         10987654321098765432109876543210
18142                                                         xx101110x01xxxxx0x0110xxxxxxxxxx
18143                                                         not.  */
18144                                                      return 242;
18145                                                    }
18146                                                  else
18147                                                    {
18148                                                      /* 33222222222211111111110000000000
18149                                                         10987654321098765432109876543210
18150                                                         xx101110x11xxxxx0x0110xxxxxxxxxx
18151                                                         rbit.  */
18152                                                      return 244;
18153                                                    }
18154                                                }
18155                                              else
18156                                                {
18157                                                  if (((word >> 14) & 0x1) == 0)
18158                                                    {
18159                                                      if (((word >> 16) & 0x1) == 0)
18160                                                        {
18161                                                          if (((word >> 20) & 0x1) == 0)
18162                                                            {
18163                                                              /* 33222222222211111111110000000000
18164                                                                 10987654321098765432109876543210
18165                                                                 xx101110xx10xxx0001110xxxxxxxxxx
18166                                                                 usqadd.  */
18167                                                              return 215;
18168                                                            }
18169                                                          else
18170                                                            {
18171                                                              /* 33222222222211111111110000000000
18172                                                                 10987654321098765432109876543210
18173                                                                 xx101110xx11xxx0001110xxxxxxxxxx
18174                                                                 uaddlv.  */
18175                                                              return 33;
18176                                                            }
18177                                                        }
18178                                                      else
18179                                                        {
18180                                                          if (((word >> 30) & 0x1) == 0)
18181                                                            {
18182                                                              /* 33222222222211111111110000000000
18183                                                                 10987654321098765432109876543210
18184                                                                 x0101110xx1xxxx1001110xxxxxxxxxx
18185                                                                 shll.  */
18186                                                              return 224;
18187                                                            }
18188                                                          else
18189                                                            {
18190                                                              /* 33222222222211111111110000000000
18191                                                                 10987654321098765432109876543210
18192                                                                 x1101110xx1xxxx1001110xxxxxxxxxx
18193                                                                 shll2.  */
18194                                                              return 225;
18195                                                            }
18196                                                        }
18197                                                    }
18198                                                  else
18199                                                    {
18200                                                      /* 33222222222211111111110000000000
18201                                                         10987654321098765432109876543210
18202                                                         xx101110xx1xxxxx011110xxxxxxxxxx
18203                                                         sqneg.  */
18204                                                      return 218;
18205                                                    }
18206                                                }
18207                                            }
18208                                        }
18209                                    }
18210                                  else
18211                                    {
18212                                      if (((word >> 11) & 0x1) == 0)
18213                                        {
18214                                          if (((word >> 12) & 0x1) == 0)
18215                                            {
18216                                              if (((word >> 13) & 0x1) == 0)
18217                                                {
18218                                                  if (((word >> 14) & 0x1) == 0)
18219                                                    {
18220                                                      /* 33222222222211111111110000000000
18221                                                         10987654321098765432109876543210
18222                                                         xx101110xx1xxxxx000001xxxxxxxxxx
18223                                                         uhadd.  */
18224                                                      return 320;
18225                                                    }
18226                                                  else
18227                                                    {
18228                                                      /* 33222222222211111111110000000000
18229                                                         10987654321098765432109876543210
18230                                                         xx101110xx1xxxxx010001xxxxxxxxxx
18231                                                         ushl.  */
18232                                                      return 327;
18233                                                    }
18234                                                }
18235                                              else
18236                                                {
18237                                                  if (((word >> 14) & 0x1) == 0)
18238                                                    {
18239                                                      /* 33222222222211111111110000000000
18240                                                         10987654321098765432109876543210
18241                                                         xx101110xx1xxxxx001001xxxxxxxxxx
18242                                                         uhsub.  */
18243                                                      return 323;
18244                                                    }
18245                                                  else
18246                                                    {
18247                                                      /* 33222222222211111111110000000000
18248                                                         10987654321098765432109876543210
18249                                                         xx101110xx1xxxxx011001xxxxxxxxxx
18250                                                         umax.  */
18251                                                      return 331;
18252                                                    }
18253                                                }
18254                                            }
18255                                          else
18256                                            {
18257                                              if (((word >> 13) & 0x1) == 0)
18258                                                {
18259                                                  if (((word >> 14) & 0x1) == 0)
18260                                                    {
18261                                                      /* 33222222222211111111110000000000
18262                                                         10987654321098765432109876543210
18263                                                         xx101110xx1xxxxx000101xxxxxxxxxx
18264                                                         urhadd.  */
18265                                                      return 322;
18266                                                    }
18267                                                  else
18268                                                    {
18269                                                      /* 33222222222211111111110000000000
18270                                                         10987654321098765432109876543210
18271                                                         xx101110xx1xxxxx010101xxxxxxxxxx
18272                                                         urshl.  */
18273                                                      return 329;
18274                                                    }
18275                                                }
18276                                              else
18277                                                {
18278                                                  if (((word >> 14) & 0x1) == 0)
18279                                                    {
18280                                                      /* 33222222222211111111110000000000
18281                                                         10987654321098765432109876543210
18282                                                         xx101110xx1xxxxx001101xxxxxxxxxx
18283                                                         cmhi.  */
18284                                                      return 325;
18285                                                    }
18286                                                  else
18287                                                    {
18288                                                      /* 33222222222211111111110000000000
18289                                                         10987654321098765432109876543210
18290                                                         xx101110xx1xxxxx011101xxxxxxxxxx
18291                                                         uabd.  */
18292                                                      return 333;
18293                                                    }
18294                                                }
18295                                            }
18296                                        }
18297                                      else
18298                                        {
18299                                          if (((word >> 12) & 0x1) == 0)
18300                                            {
18301                                              if (((word >> 13) & 0x1) == 0)
18302                                                {
18303                                                  if (((word >> 14) & 0x1) == 0)
18304                                                    {
18305                                                      /* 33222222222211111111110000000000
18306                                                         10987654321098765432109876543210
18307                                                         xx101110xx1xxxxx000011xxxxxxxxxx
18308                                                         uqadd.  */
18309                                                      return 321;
18310                                                    }
18311                                                  else
18312                                                    {
18313                                                      /* 33222222222211111111110000000000
18314                                                         10987654321098765432109876543210
18315                                                         xx101110xx1xxxxx010011xxxxxxxxxx
18316                                                         uqshl.  */
18317                                                      return 328;
18318                                                    }
18319                                                }
18320                                              else
18321                                                {
18322                                                  if (((word >> 14) & 0x1) == 0)
18323                                                    {
18324                                                      /* 33222222222211111111110000000000
18325                                                         10987654321098765432109876543210
18326                                                         xx101110xx1xxxxx001011xxxxxxxxxx
18327                                                         uqsub.  */
18328                                                      return 324;
18329                                                    }
18330                                                  else
18331                                                    {
18332                                                      /* 33222222222211111111110000000000
18333                                                         10987654321098765432109876543210
18334                                                         xx101110xx1xxxxx011011xxxxxxxxxx
18335                                                         umin.  */
18336                                                      return 332;
18337                                                    }
18338                                                }
18339                                            }
18340                                          else
18341                                            {
18342                                              if (((word >> 13) & 0x1) == 0)
18343                                                {
18344                                                  if (((word >> 14) & 0x1) == 0)
18345                                                    {
18346                                                      if (((word >> 22) & 0x1) == 0)
18347                                                        {
18348                                                          if (((word >> 23) & 0x1) == 0)
18349                                                            {
18350                                                              /* 33222222222211111111110000000000
18351                                                                 10987654321098765432109876543210
18352                                                                 xx101110001xxxxx000111xxxxxxxxxx
18353                                                                 eor.  */
18354                                                              return 356;
18355                                                            }
18356                                                          else
18357                                                            {
18358                                                              /* 33222222222211111111110000000000
18359                                                                 10987654321098765432109876543210
18360                                                                 xx101110101xxxxx000111xxxxxxxxxx
18361                                                                 bit.  */
18362                                                              return 368;
18363                                                            }
18364                                                        }
18365                                                      else
18366                                                        {
18367                                                          if (((word >> 23) & 0x1) == 0)
18368                                                            {
18369                                                              /* 33222222222211111111110000000000
18370                                                                 10987654321098765432109876543210
18371                                                                 xx101110011xxxxx000111xxxxxxxxxx
18372                                                                 bsl.  */
18373                                                              return 357;
18374                                                            }
18375                                                          else
18376                                                            {
18377                                                              /* 33222222222211111111110000000000
18378                                                                 10987654321098765432109876543210
18379                                                                 xx101110111xxxxx000111xxxxxxxxxx
18380                                                                 bif.  */
18381                                                              return 369;
18382                                                            }
18383                                                        }
18384                                                    }
18385                                                  else
18386                                                    {
18387                                                      /* 33222222222211111111110000000000
18388                                                         10987654321098765432109876543210
18389                                                         xx101110xx1xxxxx010111xxxxxxxxxx
18390                                                         uqrshl.  */
18391                                                      return 330;
18392                                                    }
18393                                                }
18394                                              else
18395                                                {
18396                                                  if (((word >> 14) & 0x1) == 0)
18397                                                    {
18398                                                      /* 33222222222211111111110000000000
18399                                                         10987654321098765432109876543210
18400                                                         xx101110xx1xxxxx001111xxxxxxxxxx
18401                                                         cmhs.  */
18402                                                      return 326;
18403                                                    }
18404                                                  else
18405                                                    {
18406                                                      /* 33222222222211111111110000000000
18407                                                         10987654321098765432109876543210
18408                                                         xx101110xx1xxxxx011111xxxxxxxxxx
18409                                                         uaba.  */
18410                                                      return 334;
18411                                                    }
18412                                                }
18413                                            }
18414                                        }
18415                                    }
18416                                }
18417                            }
18418                          else
18419                            {
18420                              if (((word >> 10) & 0x1) == 0)
18421                                {
18422                                  if (((word >> 11) & 0x1) == 0)
18423                                    {
18424                                      if (((word >> 12) & 0x1) == 0)
18425                                        {
18426                                          if (((word >> 13) & 0x1) == 0)
18427                                            {
18428                                              if (((word >> 14) & 0x1) == 0)
18429                                                {
18430                                                  if (((word >> 29) & 0x1) == 0)
18431                                                    {
18432                                                      if (((word >> 30) & 0x1) == 0)
18433                                                        {
18434                                                          /* 33222222222211111111110000000000
18435                                                             10987654321098765432109876543210
18436                                                             x0001110xx1xxxxx100000xxxxxxxxxx
18437                                                             smlal.  */
18438                                                          return 60;
18439                                                        }
18440                                                      else
18441                                                        {
18442                                                          if (((word >> 31) & 0x1) == 0)
18443                                                            {
18444                                                              /* 33222222222211111111110000000000
18445                                                                 10987654321098765432109876543210
18446                                                                 01001110xx1xxxxx100000xxxxxxxxxx
18447                                                                 smlal2.  */
18448                                                              return 61;
18449                                                            }
18450                                                          else
18451                                                            {
18452                                                              /* 33222222222211111111110000000000
18453                                                                 10987654321098765432109876543210
18454                                                                 11001110xx1xxxxx100000xxxxxxxxxx
18455                                                                 sha512h.  */
18456                                                              return 2341;
18457                                                            }
18458                                                        }
18459                                                    }
18460                                                  else
18461                                                    {
18462                                                      if (((word >> 30) & 0x1) == 0)
18463                                                        {
18464                                                          /* 33222222222211111111110000000000
18465                                                             10987654321098765432109876543210
18466                                                             x0101110xx1xxxxx100000xxxxxxxxxx
18467                                                             umlal.  */
18468                                                          return 92;
18469                                                        }
18470                                                      else
18471                                                        {
18472                                                          /* 33222222222211111111110000000000
18473                                                             10987654321098765432109876543210
18474                                                             x1101110xx1xxxxx100000xxxxxxxxxx
18475                                                             umlal2.  */
18476                                                          return 93;
18477                                                        }
18478                                                    }
18479                                                }
18480                                              else
18481                                                {
18482                                                  if (((word >> 29) & 0x1) == 0)
18483                                                    {
18484                                                      if (((word >> 30) & 0x1) == 0)
18485                                                        {
18486                                                          /* 33222222222211111111110000000000
18487                                                             10987654321098765432109876543210
18488                                                             x0001110xx1xxxxx110000xxxxxxxxxx
18489                                                             smull.  */
18490                                                          return 68;
18491                                                        }
18492                                                      else
18493                                                        {
18494                                                          if (((word >> 31) & 0x1) == 0)
18495                                                            {
18496                                                              /* 33222222222211111111110000000000
18497                                                                 10987654321098765432109876543210
18498                                                                 01001110xx1xxxxx110000xxxxxxxxxx
18499                                                                 smull2.  */
18500                                                              return 69;
18501                                                            }
18502                                                          else
18503                                                            {
18504                                                              /* 33222222222211111111110000000000
18505                                                                 10987654321098765432109876543210
18506                                                                 11001110xx1xxxxx110000xxxxxxxxxx
18507                                                                 sm3partw1.  */
18508                                                              return 2354;
18509                                                            }
18510                                                        }
18511                                                    }
18512                                                  else
18513                                                    {
18514                                                      if (((word >> 30) & 0x1) == 0)
18515                                                        {
18516                                                          /* 33222222222211111111110000000000
18517                                                             10987654321098765432109876543210
18518                                                             x0101110xx1xxxxx110000xxxxxxxxxx
18519                                                             umull.  */
18520                                                          return 96;
18521                                                        }
18522                                                      else
18523                                                        {
18524                                                          /* 33222222222211111111110000000000
18525                                                             10987654321098765432109876543210
18526                                                             x1101110xx1xxxxx110000xxxxxxxxxx
18527                                                             umull2.  */
18528                                                          return 97;
18529                                                        }
18530                                                    }
18531                                                }
18532                                            }
18533                                          else
18534                                            {
18535                                              if (((word >> 14) & 0x1) == 0)
18536                                                {
18537                                                  if (((word >> 29) & 0x1) == 0)
18538                                                    {
18539                                                      if (((word >> 30) & 0x1) == 0)
18540                                                        {
18541                                                          /* 33222222222211111111110000000000
18542                                                             10987654321098765432109876543210
18543                                                             x0001110xx1xxxxx101000xxxxxxxxxx
18544                                                             smlsl.  */
18545                                                          return 64;
18546                                                        }
18547                                                      else
18548                                                        {
18549                                                          /* 33222222222211111111110000000000
18550                                                             10987654321098765432109876543210
18551                                                             x1001110xx1xxxxx101000xxxxxxxxxx
18552                                                             smlsl2.  */
18553                                                          return 65;
18554                                                        }
18555                                                    }
18556                                                  else
18557                                                    {
18558                                                      if (((word >> 30) & 0x1) == 0)
18559                                                        {
18560                                                          /* 33222222222211111111110000000000
18561                                                             10987654321098765432109876543210
18562                                                             x0101110xx1xxxxx101000xxxxxxxxxx
18563                                                             umlsl.  */
18564                                                          return 94;
18565                                                        }
18566                                                      else
18567                                                        {
18568                                                          /* 33222222222211111111110000000000
18569                                                             10987654321098765432109876543210
18570                                                             x1101110xx1xxxxx101000xxxxxxxxxx
18571                                                             umlsl2.  */
18572                                                          return 95;
18573                                                        }
18574                                                    }
18575                                                }
18576                                              else
18577                                                {
18578                                                  if (((word >> 22) & 0x1) == 0)
18579                                                    {
18580                                                      if (((word >> 30) & 0x1) == 0)
18581                                                        {
18582                                                          /* 33222222222211111111110000000000
18583                                                             10987654321098765432109876543210
18584                                                             x0x01110x01xxxxx111000xxxxxxxxxx
18585                                                             pmull.  */
18586                                                          return 72;
18587                                                        }
18588                                                      else
18589                                                        {
18590                                                          /* 33222222222211111111110000000000
18591                                                             10987654321098765432109876543210
18592                                                             x1x01110x01xxxxx111000xxxxxxxxxx
18593                                                             pmull2.  */
18594                                                          return 74;
18595                                                        }
18596                                                    }
18597                                                  else
18598                                                    {
18599                                                      if (((word >> 30) & 0x1) == 0)
18600                                                        {
18601                                                          /* 33222222222211111111110000000000
18602                                                             10987654321098765432109876543210
18603                                                             x0x01110x11xxxxx111000xxxxxxxxxx
18604                                                             pmull.  */
18605                                                          return 73;
18606                                                        }
18607                                                      else
18608                                                        {
18609                                                          /* 33222222222211111111110000000000
18610                                                             10987654321098765432109876543210
18611                                                             x1x01110x11xxxxx111000xxxxxxxxxx
18612                                                             pmull2.  */
18613                                                          return 75;
18614                                                        }
18615                                                    }
18616                                                }
18617                                            }
18618                                        }
18619                                      else
18620                                        {
18621                                          if (((word >> 13) & 0x1) == 0)
18622                                            {
18623                                              if (((word >> 14) & 0x1) == 0)
18624                                                {
18625                                                  if (((word >> 30) & 0x1) == 0)
18626                                                    {
18627                                                      /* 33222222222211111111110000000000
18628                                                         10987654321098765432109876543210
18629                                                         x0x01110xx1xxxxx100100xxxxxxxxxx
18630                                                         sqdmlal.  */
18631                                                      return 62;
18632                                                    }
18633                                                  else
18634                                                    {
18635                                                      /* 33222222222211111111110000000000
18636                                                         10987654321098765432109876543210
18637                                                         x1x01110xx1xxxxx100100xxxxxxxxxx
18638                                                         sqdmlal2.  */
18639                                                      return 63;
18640                                                    }
18641                                                }
18642                                              else
18643                                                {
18644                                                  if (((word >> 30) & 0x1) == 0)
18645                                                    {
18646                                                      /* 33222222222211111111110000000000
18647                                                         10987654321098765432109876543210
18648                                                         x0x01110xx1xxxxx110100xxxxxxxxxx
18649                                                         sqdmull.  */
18650                                                      return 70;
18651                                                    }
18652                                                  else
18653                                                    {
18654                                                      /* 33222222222211111111110000000000
18655                                                         10987654321098765432109876543210
18656                                                         x1x01110xx1xxxxx110100xxxxxxxxxx
18657                                                         sqdmull2.  */
18658                                                      return 71;
18659                                                    }
18660                                                }
18661                                            }
18662                                          else
18663                                            {
18664                                              if (((word >> 30) & 0x1) == 0)
18665                                                {
18666                                                  /* 33222222222211111111110000000000
18667                                                     10987654321098765432109876543210
18668                                                     x0x01110xx1xxxxx1x1100xxxxxxxxxx
18669                                                     sqdmlsl.  */
18670                                                  return 66;
18671                                                }
18672                                              else
18673                                                {
18674                                                  /* 33222222222211111111110000000000
18675                                                     10987654321098765432109876543210
18676                                                     x1x01110xx1xxxxx1x1100xxxxxxxxxx
18677                                                     sqdmlsl2.  */
18678                                                  return 67;
18679                                                }
18680                                            }
18681                                        }
18682                                    }
18683                                  else
18684                                    {
18685                                      if (((word >> 12) & 0x1) == 0)
18686                                        {
18687                                          if (((word >> 13) & 0x1) == 0)
18688                                            {
18689                                              if (((word >> 14) & 0x1) == 0)
18690                                                {
18691                                                  if (((word >> 29) & 0x1) == 0)
18692                                                    {
18693                                                      if (((word >> 31) & 0x1) == 0)
18694                                                        {
18695                                                          if (((word >> 16) & 0x1) == 0)
18696                                                            {
18697                                                              /* 33222222222211111111110000000000
18698                                                                 10987654321098765432109876543210
18699                                                                 0x001110xx1xxxx0100010xxxxxxxxxx
18700                                                                 cmgt.  */
18701                                                              return 170;
18702                                                            }
18703                                                          else
18704                                                            {
18705                                                              if (((word >> 19) & 0x1) == 0)
18706                                                                {
18707                                                                  if (((word >> 23) & 0x1) == 0)
18708                                                                    {
18709                                                                      /* 33222222222211111111110000000000
18710                                                                         10987654321098765432109876543210
18711                                                                         0x0011100x1x0xx1100010xxxxxxxxxx
18712                                                                         frintn.  */
18713                                                                      return 182;
18714                                                                    }
18715                                                                  else
18716                                                                    {
18717                                                                      /* 33222222222211111111110000000000
18718                                                                         10987654321098765432109876543210
18719                                                                         0x0011101x1x0xx1100010xxxxxxxxxx
18720                                                                         frintp.  */
18721                                                                      return 202;
18722                                                                    }
18723                                                                }
18724                                                              else
18725                                                                {
18726                                                                  if (((word >> 23) & 0x1) == 0)
18727                                                                    {
18728                                                                      /* 33222222222211111111110000000000
18729                                                                         10987654321098765432109876543210
18730                                                                         0x0011100x1x1xx1100010xxxxxxxxxx
18731                                                                         frintn.  */
18732                                                                      return 183;
18733                                                                    }
18734                                                                  else
18735                                                                    {
18736                                                                      /* 33222222222211111111110000000000
18737                                                                         10987654321098765432109876543210
18738                                                                         0x0011101x1x1xx1100010xxxxxxxxxx
18739                                                                         frintp.  */
18740                                                                      return 203;
18741                                                                    }
18742                                                                }
18743                                                            }
18744                                                        }
18745                                                      else
18746                                                        {
18747                                                          /* 33222222222211111111110000000000
18748                                                             10987654321098765432109876543210
18749                                                             1x001110xx1xxxxx100010xxxxxxxxxx
18750                                                             sha512su1.  */
18751                                                          return 2344;
18752                                                        }
18753                                                    }
18754                                                  else
18755                                                    {
18756                                                      if (((word >> 16) & 0x1) == 0)
18757                                                        {
18758                                                          /* 33222222222211111111110000000000
18759                                                             10987654321098765432109876543210
18760                                                             xx101110xx1xxxx0100010xxxxxxxxxx
18761                                                             cmge.  */
18762                                                          return 219;
18763                                                        }
18764                                                      else
18765                                                        {
18766                                                          if (((word >> 19) & 0x1) == 0)
18767                                                            {
18768                                                              /* 33222222222211111111110000000000
18769                                                                 10987654321098765432109876543210
18770                                                                 xx101110xx1x0xx1100010xxxxxxxxxx
18771                                                                 frinta.  */
18772                                                              return 230;
18773                                                            }
18774                                                          else
18775                                                            {
18776                                                              /* 33222222222211111111110000000000
18777                                                                 10987654321098765432109876543210
18778                                                                 xx101110xx1x1xx1100010xxxxxxxxxx
18779                                                                 frinta.  */
18780                                                              return 231;
18781                                                            }
18782                                                        }
18783                                                    }
18784                                                }
18785                                              else
18786                                                {
18787                                                  if (((word >> 23) & 0x1) == 0)
18788                                                    {
18789                                                      if (((word >> 29) & 0x1) == 0)
18790                                                        {
18791                                                          if (((word >> 31) & 0x1) == 0)
18792                                                            {
18793                                                              if (((word >> 16) & 0x1) == 0)
18794                                                                {
18795                                                                  /* 33222222222211111111110000000000
18796                                                                     10987654321098765432109876543210
18797                                                                     0x0011100x1xxxx0110010xxxxxxxxxx
18798                                                                     fmaxnmv.  */
18799                                                                  return 37;
18800                                                                }
18801                                                              else
18802                                                                {
18803                                                                  if (((word >> 19) & 0x1) == 0)
18804                                                                    {
18805                                                                      /* 33222222222211111111110000000000
18806                                                                         10987654321098765432109876543210
18807                                                                         0x0011100x1x0xx1110010xxxxxxxxxx
18808                                                                         fcvtas.  */
18809                                                                      return 190;
18810                                                                    }
18811                                                                  else
18812                                                                    {
18813                                                                      /* 33222222222211111111110000000000
18814                                                                         10987654321098765432109876543210
18815                                                                         0x0011100x1x1xx1110010xxxxxxxxxx
18816                                                                         fcvtas.  */
18817                                                                      return 191;
18818                                                                    }
18819                                                                }
18820                                                            }
18821                                                          else
18822                                                            {
18823                                                              /* 33222222222211111111110000000000
18824                                                                 10987654321098765432109876543210
18825                                                                 1x0011100x1xxxxx110010xxxxxxxxxx
18826                                                                 sm4ekey.  */
18827                                                              return 2357;
18828                                                            }
18829                                                        }
18830                                                      else
18831                                                        {
18832                                                          if (((word >> 16) & 0x1) == 0)
18833                                                            {
18834                                                              /* 33222222222211111111110000000000
18835                                                                 10987654321098765432109876543210
18836                                                                 xx1011100x1xxxx0110010xxxxxxxxxx
18837                                                                 fmaxnmv.  */
18838                                                              return 36;
18839                                                            }
18840                                                          else
18841                                                            {
18842                                                              if (((word >> 19) & 0x1) == 0)
18843                                                                {
18844                                                                  /* 33222222222211111111110000000000
18845                                                                     10987654321098765432109876543210
18846                                                                     xx1011100x1x0xx1110010xxxxxxxxxx
18847                                                                     fcvtau.  */
18848                                                                  return 238;
18849                                                                }
18850                                                              else
18851                                                                {
18852                                                                  /* 33222222222211111111110000000000
18853                                                                     10987654321098765432109876543210
18854                                                                     xx1011100x1x1xx1110010xxxxxxxxxx
18855                                                                     fcvtau.  */
18856                                                                  return 239;
18857                                                                }
18858                                                            }
18859                                                        }
18860                                                    }
18861                                                  else
18862                                                    {
18863                                                      if (((word >> 16) & 0x1) == 0)
18864                                                        {
18865                                                          if (((word >> 19) & 0x1) == 0)
18866                                                            {
18867                                                              if (((word >> 20) & 0x1) == 0)
18868                                                                {
18869                                                                  if (((word >> 29) & 0x1) == 0)
18870                                                                    {
18871                                                                      /* 33222222222211111111110000000000
18872                                                                         10987654321098765432109876543210
18873                                                                         xx0011101x100xx0110010xxxxxxxxxx
18874                                                                         fcmgt.  */
18875                                                                      return 194;
18876                                                                    }
18877                                                                  else
18878                                                                    {
18879                                                                      /* 33222222222211111111110000000000
18880                                                                         10987654321098765432109876543210
18881                                                                         xx1011101x100xx0110010xxxxxxxxxx
18882                                                                         fcmge.  */
18883                                                                      return 245;
18884                                                                    }
18885                                                                }
18886                                                              else
18887                                                                {
18888                                                                  if (((word >> 29) & 0x1) == 0)
18889                                                                    {
18890                                                                      /* 33222222222211111111110000000000
18891                                                                         10987654321098765432109876543210
18892                                                                         xx0011101x110xx0110010xxxxxxxxxx
18893                                                                         fminnmv.  */
18894                                                                      return 41;
18895                                                                    }
18896                                                                  else
18897                                                                    {
18898                                                                      /* 33222222222211111111110000000000
18899                                                                         10987654321098765432109876543210
18900                                                                         xx1011101x110xx0110010xxxxxxxxxx
18901                                                                         fminnmv.  */
18902                                                                      return 40;
18903                                                                    }
18904                                                                }
18905                                                            }
18906                                                          else
18907                                                            {
18908                                                              if (((word >> 29) & 0x1) == 0)
18909                                                                {
18910                                                                  /* 33222222222211111111110000000000
18911                                                                     10987654321098765432109876543210
18912                                                                     xx0011101x1x1xx0110010xxxxxxxxxx
18913                                                                     fcmgt.  */
18914                                                                  return 195;
18915                                                                }
18916                                                              else
18917                                                                {
18918                                                                  /* 33222222222211111111110000000000
18919                                                                     10987654321098765432109876543210
18920                                                                     xx1011101x1x1xx0110010xxxxxxxxxx
18921                                                                     fcmge.  */
18922                                                                  return 246;
18923                                                                }
18924                                                            }
18925                                                        }
18926                                                      else
18927                                                        {
18928                                                          if (((word >> 29) & 0x1) == 0)
18929                                                            {
18930                                                              /* 33222222222211111111110000000000
18931                                                                 10987654321098765432109876543210
18932                                                                 xx0011101x1xxxx1110010xxxxxxxxxx
18933                                                                 urecpe.  */
18934                                                              return 210;
18935                                                            }
18936                                                          else
18937                                                            {
18938                                                              /* 33222222222211111111110000000000
18939                                                                 10987654321098765432109876543210
18940                                                                 xx1011101x1xxxx1110010xxxxxxxxxx
18941                                                                 ursqrte.  */
18942                                                              return 257;
18943                                                            }
18944                                                        }
18945                                                    }
18946                                                }
18947                                            }
18948                                          else
18949                                            {
18950                                              if (((word >> 14) & 0x1) == 0)
18951                                                {
18952                                                  if (((word >> 16) & 0x1) == 0)
18953                                                    {
18954                                                      if (((word >> 20) & 0x1) == 0)
18955                                                        {
18956                                                          /* 33222222222211111111110000000000
18957                                                             10987654321098765432109876543210
18958                                                             xxx01110xx10xxx0101010xxxxxxxxxx
18959                                                             cmlt.  */
18960                                                          return 172;
18961                                                        }
18962                                                      else
18963                                                        {
18964                                                          if (((word >> 29) & 0x1) == 0)
18965                                                            {
18966                                                              /* 33222222222211111111110000000000
18967                                                                 10987654321098765432109876543210
18968                                                                 xx001110xx11xxx0101010xxxxxxxxxx
18969                                                                 smaxv.  */
18970                                                              return 30;
18971                                                            }
18972                                                          else
18973                                                            {
18974                                                              /* 33222222222211111111110000000000
18975                                                                 10987654321098765432109876543210
18976                                                                 xx101110xx11xxx0101010xxxxxxxxxx
18977                                                                 umaxv.  */
18978                                                              return 34;
18979                                                            }
18980                                                        }
18981                                                    }
18982                                                  else
18983                                                    {
18984                                                      if (((word >> 19) & 0x1) == 0)
18985                                                        {
18986                                                          if (((word >> 20) & 0x1) == 0)
18987                                                            {
18988                                                              if (((word >> 23) & 0x1) == 0)
18989                                                                {
18990                                                                  if (((word >> 29) & 0x1) == 0)
18991                                                                    {
18992                                                                      /* 33222222222211111111110000000000
18993                                                                         10987654321098765432109876543210
18994                                                                         xx0011100x100xx1101010xxxxxxxxxx
18995                                                                         fcvtns.  */
18996                                                                      return 186;
18997                                                                    }
18998                                                                  else
18999                                                                    {
19000                                                                      /* 33222222222211111111110000000000
19001                                                                         10987654321098765432109876543210
19002                                                                         xx1011100x100xx1101010xxxxxxxxxx
19003                                                                         fcvtnu.  */
19004                                                                      return 234;
19005                                                                    }
19006                                                                }
19007                                                              else
19008                                                                {
19009                                                                  if (((word >> 29) & 0x1) == 0)
19010                                                                    {
19011                                                                      /* 33222222222211111111110000000000
19012                                                                         10987654321098765432109876543210
19013                                                                         xx0011101x100xx1101010xxxxxxxxxx
19014                                                                         fcvtps.  */
19015                                                                      return 206;
19016                                                                    }
19017                                                                  else
19018                                                                    {
19019                                                                      /* 33222222222211111111110000000000
19020                                                                         10987654321098765432109876543210
19021                                                                         xx1011101x100xx1101010xxxxxxxxxx
19022                                                                         fcvtpu.  */
19023                                                                      return 253;
19024                                                                    }
19025                                                                }
19026                                                            }
19027                                                          else
19028                                                            {
19029                                                              if (((word >> 29) & 0x1) == 0)
19030                                                                {
19031                                                                  /* 33222222222211111111110000000000
19032                                                                     10987654321098765432109876543210
19033                                                                     xx001110xx110xx1101010xxxxxxxxxx
19034                                                                     sminv.  */
19035                                                                  return 31;
19036                                                                }
19037                                                              else
19038                                                                {
19039                                                                  /* 33222222222211111111110000000000
19040                                                                     10987654321098765432109876543210
19041                                                                     xx101110xx110xx1101010xxxxxxxxxx
19042                                                                     uminv.  */
19043                                                                  return 35;
19044                                                                }
19045                                                            }
19046                                                        }
19047                                                      else
19048                                                        {
19049                                                          if (((word >> 23) & 0x1) == 0)
19050                                                            {
19051                                                              if (((word >> 29) & 0x1) == 0)
19052                                                                {
19053                                                                  /* 33222222222211111111110000000000
19054                                                                     10987654321098765432109876543210
19055                                                                     xx0011100x1x1xx1101010xxxxxxxxxx
19056                                                                     fcvtns.  */
19057                                                                  return 187;
19058                                                                }
19059                                                              else
19060                                                                {
19061                                                                  /* 33222222222211111111110000000000
19062                                                                     10987654321098765432109876543210
19063                                                                     xx1011100x1x1xx1101010xxxxxxxxxx
19064                                                                     fcvtnu.  */
19065                                                                  return 235;
19066                                                                }
19067                                                            }
19068                                                          else
19069                                                            {
19070                                                              if (((word >> 29) & 0x1) == 0)
19071                                                                {
19072                                                                  /* 33222222222211111111110000000000
19073                                                                     10987654321098765432109876543210
19074                                                                     xx0011101x1x1xx1101010xxxxxxxxxx
19075                                                                     fcvtps.  */
19076                                                                  return 207;
19077                                                                }
19078                                                              else
19079                                                                {
19080                                                                  /* 33222222222211111111110000000000
19081                                                                     10987654321098765432109876543210
19082                                                                     xx1011101x1x1xx1101010xxxxxxxxxx
19083                                                                     fcvtpu.  */
19084                                                                  return 254;
19085                                                                }
19086                                                            }
19087                                                        }
19088                                                    }
19089                                                }
19090                                              else
19091                                                {
19092                                                  if (((word >> 16) & 0x1) == 0)
19093                                                    {
19094                                                      if (((word >> 19) & 0x1) == 0)
19095                                                        {
19096                                                          /* 33222222222211111111110000000000
19097                                                             10987654321098765432109876543210
19098                                                             xxx01110xx1x0xx0111010xxxxxxxxxx
19099                                                             fcmlt.  */
19100                                                          return 198;
19101                                                        }
19102                                                      else
19103                                                        {
19104                                                          /* 33222222222211111111110000000000
19105                                                             10987654321098765432109876543210
19106                                                             xxx01110xx1x1xx0111010xxxxxxxxxx
19107                                                             fcmlt.  */
19108                                                          return 199;
19109                                                        }
19110                                                    }
19111                                                  else
19112                                                    {
19113                                                      if (((word >> 29) & 0x1) == 0)
19114                                                        {
19115                                                          /* 33222222222211111111110000000000
19116                                                             10987654321098765432109876543210
19117                                                             xx001110xx1xxxx1111010xxxxxxxxxx
19118                                                             frint32z.  */
19119                                                          return 158;
19120                                                        }
19121                                                      else
19122                                                        {
19123                                                          /* 33222222222211111111110000000000
19124                                                             10987654321098765432109876543210
19125                                                             xx101110xx1xxxx1111010xxxxxxxxxx
19126                                                             frint32x.  */
19127                                                          return 159;
19128                                                        }
19129                                                    }
19130                                                }
19131                                            }
19132                                        }
19133                                      else
19134                                        {
19135                                          if (((word >> 13) & 0x1) == 0)
19136                                            {
19137                                              if (((word >> 14) & 0x1) == 0)
19138                                                {
19139                                                  if (((word >> 16) & 0x1) == 0)
19140                                                    {
19141                                                      if (((word >> 29) & 0x1) == 0)
19142                                                        {
19143                                                          /* 33222222222211111111110000000000
19144                                                             10987654321098765432109876543210
19145                                                             xx001110xx1xxxx0100110xxxxxxxxxx
19146                                                             cmeq.  */
19147                                                          return 171;
19148                                                        }
19149                                                      else
19150                                                        {
19151                                                          /* 33222222222211111111110000000000
19152                                                             10987654321098765432109876543210
19153                                                             xx101110xx1xxxx0100110xxxxxxxxxx
19154                                                             cmle.  */
19155                                                          return 220;
19156                                                        }
19157                                                    }
19158                                                  else
19159                                                    {
19160                                                      if (((word >> 19) & 0x1) == 0)
19161                                                        {
19162                                                          if (((word >> 23) & 0x1) == 0)
19163                                                            {
19164                                                              if (((word >> 29) & 0x1) == 0)
19165                                                                {
19166                                                                  /* 33222222222211111111110000000000
19167                                                                     10987654321098765432109876543210
19168                                                                     xx0011100x1x0xx1100110xxxxxxxxxx
19169                                                                     frintm.  */
19170                                                                  return 184;
19171                                                                }
19172                                                              else
19173                                                                {
19174                                                                  /* 33222222222211111111110000000000
19175                                                                     10987654321098765432109876543210
19176                                                                     xx1011100x1x0xx1100110xxxxxxxxxx
19177                                                                     frintx.  */
19178                                                                  return 232;
19179                                                                }
19180                                                            }
19181                                                          else
19182                                                            {
19183                                                              if (((word >> 29) & 0x1) == 0)
19184                                                                {
19185                                                                  /* 33222222222211111111110000000000
19186                                                                     10987654321098765432109876543210
19187                                                                     xx0011101x1x0xx1100110xxxxxxxxxx
19188                                                                     frintz.  */
19189                                                                  return 204;
19190                                                                }
19191                                                              else
19192                                                                {
19193                                                                  /* 33222222222211111111110000000000
19194                                                                     10987654321098765432109876543210
19195                                                                     xx1011101x1x0xx1100110xxxxxxxxxx
19196                                                                     frinti.  */
19197                                                                  return 251;
19198                                                                }
19199                                                            }
19200                                                        }
19201                                                      else
19202                                                        {
19203                                                          if (((word >> 23) & 0x1) == 0)
19204                                                            {
19205                                                              if (((word >> 29) & 0x1) == 0)
19206                                                                {
19207                                                                  /* 33222222222211111111110000000000
19208                                                                     10987654321098765432109876543210
19209                                                                     xx0011100x1x1xx1100110xxxxxxxxxx
19210                                                                     frintm.  */
19211                                                                  return 185;
19212                                                                }
19213                                                              else
19214                                                                {
19215                                                                  /* 33222222222211111111110000000000
19216                                                                     10987654321098765432109876543210
19217                                                                     xx1011100x1x1xx1100110xxxxxxxxxx
19218                                                                     frintx.  */
19219                                                                  return 233;
19220                                                                }
19221                                                            }
19222                                                          else
19223                                                            {
19224                                                              if (((word >> 29) & 0x1) == 0)
19225                                                                {
19226                                                                  /* 33222222222211111111110000000000
19227                                                                     10987654321098765432109876543210
19228                                                                     xx0011101x1x1xx1100110xxxxxxxxxx
19229                                                                     frintz.  */
19230                                                                  return 205;
19231                                                                }
19232                                                              else
19233                                                                {
19234                                                                  /* 33222222222211111111110000000000
19235                                                                     10987654321098765432109876543210
19236                                                                     xx1011101x1x1xx1100110xxxxxxxxxx
19237                                                                     frinti.  */
19238                                                                  return 252;
19239                                                                }
19240                                                            }
19241                                                        }
19242                                                    }
19243                                                }
19244                                              else
19245                                                {
19246                                                  if (((word >> 16) & 0x1) == 0)
19247                                                    {
19248                                                      if (((word >> 19) & 0x1) == 0)
19249                                                        {
19250                                                          if (((word >> 29) & 0x1) == 0)
19251                                                            {
19252                                                              /* 33222222222211111111110000000000
19253                                                                 10987654321098765432109876543210
19254                                                                 xx001110xx1x0xx0110110xxxxxxxxxx
19255                                                                 fcmeq.  */
19256                                                              return 196;
19257                                                            }
19258                                                          else
19259                                                            {
19260                                                              /* 33222222222211111111110000000000
19261                                                                 10987654321098765432109876543210
19262                                                                 xx101110xx1x0xx0110110xxxxxxxxxx
19263                                                                 fcmle.  */
19264                                                              return 247;
19265                                                            }
19266                                                        }
19267                                                      else
19268                                                        {
19269                                                          if (((word >> 29) & 0x1) == 0)
19270                                                            {
19271                                                              /* 33222222222211111111110000000000
19272                                                                 10987654321098765432109876543210
19273                                                                 xx001110xx1x1xx0110110xxxxxxxxxx
19274                                                                 fcmeq.  */
19275                                                              return 197;
19276                                                            }
19277                                                          else
19278                                                            {
19279                                                              /* 33222222222211111111110000000000
19280                                                                 10987654321098765432109876543210
19281                                                                 xx101110xx1x1xx0110110xxxxxxxxxx
19282                                                                 fcmle.  */
19283                                                              return 248;
19284                                                            }
19285                                                        }
19286                                                    }
19287                                                  else
19288                                                    {
19289                                                      if (((word >> 19) & 0x1) == 0)
19290                                                        {
19291                                                          if (((word >> 23) & 0x1) == 0)
19292                                                            {
19293                                                              if (((word >> 29) & 0x1) == 0)
19294                                                                {
19295                                                                  /* 33222222222211111111110000000000
19296                                                                     10987654321098765432109876543210
19297                                                                     xx0011100x1x0xx1110110xxxxxxxxxx
19298                                                                     scvtf.  */
19299                                                                  return 192;
19300                                                                }
19301                                                              else
19302                                                                {
19303                                                                  /* 33222222222211111111110000000000
19304                                                                     10987654321098765432109876543210
19305                                                                     xx1011100x1x0xx1110110xxxxxxxxxx
19306                                                                     ucvtf.  */
19307                                                                  return 240;
19308                                                                }
19309                                                            }
19310                                                          else
19311                                                            {
19312                                                              if (((word >> 29) & 0x1) == 0)
19313                                                                {
19314                                                                  /* 33222222222211111111110000000000
19315                                                                     10987654321098765432109876543210
19316                                                                     xx0011101x1x0xx1110110xxxxxxxxxx
19317                                                                     frecpe.  */
19318                                                                  return 211;
19319                                                                }
19320                                                              else
19321                                                                {
19322                                                                  /* 33222222222211111111110000000000
19323                                                                     10987654321098765432109876543210
19324                                                                     xx1011101x1x0xx1110110xxxxxxxxxx
19325                                                                     frsqrte.  */
19326                                                                  return 258;
19327                                                                }
19328                                                            }
19329                                                        }
19330                                                      else
19331                                                        {
19332                                                          if (((word >> 23) & 0x1) == 0)
19333                                                            {
19334                                                              if (((word >> 29) & 0x1) == 0)
19335                                                                {
19336                                                                  /* 33222222222211111111110000000000
19337                                                                     10987654321098765432109876543210
19338                                                                     xx0011100x1x1xx1110110xxxxxxxxxx
19339                                                                     scvtf.  */
19340                                                                  return 193;
19341                                                                }
19342                                                              else
19343                                                                {
19344                                                                  /* 33222222222211111111110000000000
19345                                                                     10987654321098765432109876543210
19346                                                                     xx1011100x1x1xx1110110xxxxxxxxxx
19347                                                                     ucvtf.  */
19348                                                                  return 241;
19349                                                                }
19350                                                            }
19351                                                          else
19352                                                            {
19353                                                              if (((word >> 29) & 0x1) == 0)
19354                                                                {
19355                                                                  /* 33222222222211111111110000000000
19356                                                                     10987654321098765432109876543210
19357                                                                     xx0011101x1x1xx1110110xxxxxxxxxx
19358                                                                     frecpe.  */
19359                                                                  return 212;
19360                                                                }
19361                                                              else
19362                                                                {
19363                                                                  /* 33222222222211111111110000000000
19364                                                                     10987654321098765432109876543210
19365                                                                     xx1011101x1x1xx1110110xxxxxxxxxx
19366                                                                     frsqrte.  */
19367                                                                  return 259;
19368                                                                }
19369                                                            }
19370                                                        }
19371                                                    }
19372                                                }
19373                                            }
19374                                          else
19375                                            {
19376                                              if (((word >> 14) & 0x1) == 0)
19377                                                {
19378                                                  if (((word >> 16) & 0x1) == 0)
19379                                                    {
19380                                                      if (((word >> 29) & 0x1) == 0)
19381                                                        {
19382                                                          /* 33222222222211111111110000000000
19383                                                             10987654321098765432109876543210
19384                                                             xx001110xx1xxxx0101110xxxxxxxxxx
19385                                                             abs.  */
19386                                                          return 173;
19387                                                        }
19388                                                      else
19389                                                        {
19390                                                          /* 33222222222211111111110000000000
19391                                                             10987654321098765432109876543210
19392                                                             xx101110xx1xxxx0101110xxxxxxxxxx
19393                                                             neg.  */
19394                                                          return 221;
19395                                                        }
19396                                                    }
19397                                                  else
19398                                                    {
19399                                                      if (((word >> 19) & 0x1) == 0)
19400                                                        {
19401                                                          if (((word >> 20) & 0x1) == 0)
19402                                                            {
19403                                                              if (((word >> 23) & 0x1) == 0)
19404                                                                {
19405                                                                  if (((word >> 29) & 0x1) == 0)
19406                                                                    {
19407                                                                      /* 33222222222211111111110000000000
19408                                                                         10987654321098765432109876543210
19409                                                                         xx0011100x100xx1101110xxxxxxxxxx
19410                                                                         fcvtms.  */
19411                                                                      return 188;
19412                                                                    }
19413                                                                  else
19414                                                                    {
19415                                                                      /* 33222222222211111111110000000000
19416                                                                         10987654321098765432109876543210
19417                                                                         xx1011100x100xx1101110xxxxxxxxxx
19418                                                                         fcvtmu.  */
19419                                                                      return 236;
19420                                                                    }
19421                                                                }
19422                                                              else
19423                                                                {
19424                                                                  if (((word >> 29) & 0x1) == 0)
19425                                                                    {
19426                                                                      /* 33222222222211111111110000000000
19427                                                                         10987654321098765432109876543210
19428                                                                         xx0011101x100xx1101110xxxxxxxxxx
19429                                                                         fcvtzs.  */
19430                                                                      return 208;
19431                                                                    }
19432                                                                  else
19433                                                                    {
19434                                                                      /* 33222222222211111111110000000000
19435                                                                         10987654321098765432109876543210
19436                                                                         xx1011101x100xx1101110xxxxxxxxxx
19437                                                                         fcvtzu.  */
19438                                                                      return 255;
19439                                                                    }
19440                                                                }
19441                                                            }
19442                                                          else
19443                                                            {
19444                                                              /* 33222222222211111111110000000000
19445                                                                 10987654321098765432109876543210
19446                                                                 xxx01110xx110xx1101110xxxxxxxxxx
19447                                                                 addv.  */
19448                                                              return 32;
19449                                                            }
19450                                                        }
19451                                                      else
19452                                                        {
19453                                                          if (((word >> 23) & 0x1) == 0)
19454                                                            {
19455                                                              if (((word >> 29) & 0x1) == 0)
19456                                                                {
19457                                                                  /* 33222222222211111111110000000000
19458                                                                     10987654321098765432109876543210
19459                                                                     xx0011100x1x1xx1101110xxxxxxxxxx
19460                                                                     fcvtms.  */
19461                                                                  return 189;
19462                                                                }
19463                                                              else
19464                                                                {
19465                                                                  /* 33222222222211111111110000000000
19466                                                                     10987654321098765432109876543210
19467                                                                     xx1011100x1x1xx1101110xxxxxxxxxx
19468                                                                     fcvtmu.  */
19469                                                                  return 237;
19470                                                                }
19471                                                            }
19472                                                          else
19473                                                            {
19474                                                              if (((word >> 29) & 0x1) == 0)
19475                                                                {
19476                                                                  /* 33222222222211111111110000000000
19477                                                                     10987654321098765432109876543210
19478                                                                     xx0011101x1x1xx1101110xxxxxxxxxx
19479                                                                     fcvtzs.  */
19480                                                                  return 209;
19481                                                                }
19482                                                              else
19483                                                                {
19484                                                                  /* 33222222222211111111110000000000
19485                                                                     10987654321098765432109876543210
19486                                                                     xx1011101x1x1xx1101110xxxxxxxxxx
19487                                                                     fcvtzu.  */
19488                                                                  return 256;
19489                                                                }
19490                                                            }
19491                                                        }
19492                                                    }
19493                                                }
19494                                              else
19495                                                {
19496                                                  if (((word >> 16) & 0x1) == 0)
19497                                                    {
19498                                                      if (((word >> 19) & 0x1) == 0)
19499                                                        {
19500                                                          if (((word >> 20) & 0x1) == 0)
19501                                                            {
19502                                                              if (((word >> 29) & 0x1) == 0)
19503                                                                {
19504                                                                  /* 33222222222211111111110000000000
19505                                                                     10987654321098765432109876543210
19506                                                                     xx001110xx100xx0111110xxxxxxxxxx
19507                                                                     fabs.  */
19508                                                                  return 200;
19509                                                                }
19510                                                              else
19511                                                                {
19512                                                                  /* 33222222222211111111110000000000
19513                                                                     10987654321098765432109876543210
19514                                                                     xx101110xx100xx0111110xxxxxxxxxx
19515                                                                     fneg.  */
19516                                                                  return 249;
19517                                                                }
19518                                                            }
19519                                                          else
19520                                                            {
19521                                                              if (((word >> 23) & 0x1) == 0)
19522                                                                {
19523                                                                  if (((word >> 29) & 0x1) == 0)
19524                                                                    {
19525                                                                      /* 33222222222211111111110000000000
19526                                                                         10987654321098765432109876543210
19527                                                                         xx0011100x110xx0111110xxxxxxxxxx
19528                                                                         fmaxv.  */
19529                                                                      return 39;
19530                                                                    }
19531                                                                  else
19532                                                                    {
19533                                                                      /* 33222222222211111111110000000000
19534                                                                         10987654321098765432109876543210
19535                                                                         xx1011100x110xx0111110xxxxxxxxxx
19536                                                                         fmaxv.  */
19537                                                                      return 38;
19538                                                                    }
19539                                                                }
19540                                                              else
19541                                                                {
19542                                                                  if (((word >> 29) & 0x1) == 0)
19543                                                                    {
19544                                                                      /* 33222222222211111111110000000000
19545                                                                         10987654321098765432109876543210
19546                                                                         xx0011101x110xx0111110xxxxxxxxxx
19547                                                                         fminv.  */
19548                                                                      return 43;
19549                                                                    }
19550                                                                  else
19551                                                                    {
19552                                                                      /* 33222222222211111111110000000000
19553                                                                         10987654321098765432109876543210
19554                                                                         xx1011101x110xx0111110xxxxxxxxxx
19555                                                                         fminv.  */
19556                                                                      return 42;
19557                                                                    }
19558                                                                }
19559                                                            }
19560                                                        }
19561                                                      else
19562                                                        {
19563                                                          if (((word >> 29) & 0x1) == 0)
19564                                                            {
19565                                                              /* 33222222222211111111110000000000
19566                                                                 10987654321098765432109876543210
19567                                                                 xx001110xx1x1xx0111110xxxxxxxxxx
19568                                                                 fabs.  */
19569                                                              return 201;
19570                                                            }
19571                                                          else
19572                                                            {
19573                                                              /* 33222222222211111111110000000000
19574                                                                 10987654321098765432109876543210
19575                                                                 xx101110xx1x1xx0111110xxxxxxxxxx
19576                                                                 fneg.  */
19577                                                              return 250;
19578                                                            }
19579                                                        }
19580                                                    }
19581                                                  else
19582                                                    {
19583                                                      if (((word >> 19) & 0x1) == 0)
19584                                                        {
19585                                                          if (((word >> 23) & 0x1) == 0)
19586                                                            {
19587                                                              if (((word >> 29) & 0x1) == 0)
19588                                                                {
19589                                                                  /* 33222222222211111111110000000000
19590                                                                     10987654321098765432109876543210
19591                                                                     xx0011100x1x0xx1111110xxxxxxxxxx
19592                                                                     frint64z.  */
19593                                                                  return 160;
19594                                                                }
19595                                                              else
19596                                                                {
19597                                                                  /* 33222222222211111111110000000000
19598                                                                     10987654321098765432109876543210
19599                                                                     xx1011100x1x0xx1111110xxxxxxxxxx
19600                                                                     frint64x.  */
19601                                                                  return 161;
19602                                                                }
19603                                                            }
19604                                                          else
19605                                                            {
19606                                                              /* 33222222222211111111110000000000
19607                                                                 10987654321098765432109876543210
19608                                                                 xxx011101x1x0xx1111110xxxxxxxxxx
19609                                                                 fsqrt.  */
19610                                                              return 260;
19611                                                            }
19612                                                        }
19613                                                      else
19614                                                        {
19615                                                          /* 33222222222211111111110000000000
19616                                                             10987654321098765432109876543210
19617                                                             xxx01110xx1x1xx1111110xxxxxxxxxx
19618                                                             fsqrt.  */
19619                                                          return 261;
19620                                                        }
19621                                                    }
19622                                                }
19623                                            }
19624                                        }
19625                                    }
19626                                }
19627                              else
19628                                {
19629                                  if (((word >> 11) & 0x1) == 0)
19630                                    {
19631                                      if (((word >> 12) & 0x1) == 0)
19632                                        {
19633                                          if (((word >> 13) & 0x1) == 0)
19634                                            {
19635                                              if (((word >> 14) & 0x1) == 0)
19636                                                {
19637                                                  if (((word >> 29) & 0x1) == 0)
19638                                                    {
19639                                                      if (((word >> 31) & 0x1) == 0)
19640                                                        {
19641                                                          /* 33222222222211111111110000000000
19642                                                             10987654321098765432109876543210
19643                                                             0x001110xx1xxxxx100001xxxxxxxxxx
19644                                                             add.  */
19645                                                          return 283;
19646                                                        }
19647                                                      else
19648                                                        {
19649                                                          /* 33222222222211111111110000000000
19650                                                             10987654321098765432109876543210
19651                                                             1x001110xx1xxxxx100001xxxxxxxxxx
19652                                                             sha512h2.  */
19653                                                          return 2342;
19654                                                        }
19655                                                    }
19656                                                  else
19657                                                    {
19658                                                      /* 33222222222211111111110000000000
19659                                                         10987654321098765432109876543210
19660                                                         xx101110xx1xxxxx100001xxxxxxxxxx
19661                                                         sub.  */
19662                                                      return 335;
19663                                                    }
19664                                                }
19665                                              else
19666                                                {
19667                                                  if (((word >> 23) & 0x1) == 0)
19668                                                    {
19669                                                      if (((word >> 29) & 0x1) == 0)
19670                                                        {
19671                                                          if (((word >> 31) & 0x1) == 0)
19672                                                            {
19673                                                              /* 33222222222211111111110000000000
19674                                                                 10987654321098765432109876543210
19675                                                                 0x0011100x1xxxxx110001xxxxxxxxxx
19676                                                                 fmaxnm.  */
19677                                                              return 291;
19678                                                            }
19679                                                          else
19680                                                            {
19681                                                              /* 33222222222211111111110000000000
19682                                                                 10987654321098765432109876543210
19683                                                                 1x0011100x1xxxxx110001xxxxxxxxxx
19684                                                                 sm3partw2.  */
19685                                                              return 2355;
19686                                                            }
19687                                                        }
19688                                                      else
19689                                                        {
19690                                                          /* 33222222222211111111110000000000
19691                                                             10987654321098765432109876543210
19692                                                             xx1011100x1xxxxx110001xxxxxxxxxx
19693                                                             fmaxnmp.  */
19694                                                          return 342;
19695                                                        }
19696                                                    }
19697                                                  else
19698                                                    {
19699                                                      if (((word >> 29) & 0x1) == 0)
19700                                                        {
19701                                                          /* 33222222222211111111110000000000
19702                                                             10987654321098765432109876543210
19703                                                             xx0011101x1xxxxx110001xxxxxxxxxx
19704                                                             fminnm.  */
19705                                                          return 307;
19706                                                        }
19707                                                      else
19708                                                        {
19709                                                          /* 33222222222211111111110000000000
19710                                                             10987654321098765432109876543210
19711                                                             xx1011101x1xxxxx110001xxxxxxxxxx
19712                                                             fminnmp.  */
19713                                                          return 358;
19714                                                        }
19715                                                    }
19716                                                }
19717                                            }
19718                                          else
19719                                            {
19720                                              if (((word >> 14) & 0x1) == 0)
19721                                                {
19722                                                  if (((word >> 29) & 0x1) == 0)
19723                                                    {
19724                                                      /* 33222222222211111111110000000000
19725                                                         10987654321098765432109876543210
19726                                                         xx001110xx1xxxxx101001xxxxxxxxxx
19727                                                         smaxp.  */
19728                                                      return 287;
19729                                                    }
19730                                                  else
19731                                                    {
19732                                                      /* 33222222222211111111110000000000
19733                                                         10987654321098765432109876543210
19734                                                         xx101110xx1xxxxx101001xxxxxxxxxx
19735                                                         umaxp.  */
19736                                                      return 339;
19737                                                    }
19738                                                }
19739                                              else
19740                                                {
19741                                                  if (((word >> 23) & 0x1) == 0)
19742                                                    {
19743                                                      if (((word >> 29) & 0x1) == 0)
19744                                                        {
19745                                                          /* 33222222222211111111110000000000
19746                                                             10987654321098765432109876543210
19747                                                             xx0011100x1xxxxx111001xxxxxxxxxx
19748                                                             fcmeq.  */
19749                                                          return 299;
19750                                                        }
19751                                                      else
19752                                                        {
19753                                                          /* 33222222222211111111110000000000
19754                                                             10987654321098765432109876543210
19755                                                             xx1011100x1xxxxx111001xxxxxxxxxx
19756                                                             fcmge.  */
19757                                                          return 348;
19758                                                        }
19759                                                    }
19760                                                  else
19761                                                    {
19762                                                      /* 33222222222211111111110000000000
19763                                                         10987654321098765432109876543210
19764                                                         xxx011101x1xxxxx111001xxxxxxxxxx
19765                                                         fcmgt.  */
19766                                                      return 362;
19767                                                    }
19768                                                }
19769                                            }
19770                                        }
19771                                      else
19772                                        {
19773                                          if (((word >> 13) & 0x1) == 0)
19774                                            {
19775                                              if (((word >> 14) & 0x1) == 0)
19776                                                {
19777                                                  if (((word >> 29) & 0x1) == 0)
19778                                                    {
19779                                                      /* 33222222222211111111110000000000
19780                                                         10987654321098765432109876543210
19781                                                         xx001110xx1xxxxx100101xxxxxxxxxx
19782                                                         mla.  */
19783                                                      return 285;
19784                                                    }
19785                                                  else
19786                                                    {
19787                                                      /* 33222222222211111111110000000000
19788                                                         10987654321098765432109876543210
19789                                                         xx101110xx1xxxxx100101xxxxxxxxxx
19790                                                         mls.  */
19791                                                      return 337;
19792                                                    }
19793                                                }
19794                                              else
19795                                                {
19796                                                  if (((word >> 23) & 0x1) == 0)
19797                                                    {
19798                                                      if (((word >> 29) & 0x1) == 0)
19799                                                        {
19800                                                          /* 33222222222211111111110000000000
19801                                                             10987654321098765432109876543210
19802                                                             xx0011100x1xxxxx110101xxxxxxxxxx
19803                                                             fadd.  */
19804                                                          return 295;
19805                                                        }
19806                                                      else
19807                                                        {
19808                                                          /* 33222222222211111111110000000000
19809                                                             10987654321098765432109876543210
19810                                                             xx1011100x1xxxxx110101xxxxxxxxxx
19811                                                             faddp.  */
19812                                                          return 344;
19813                                                        }
19814                                                    }
19815                                                  else
19816                                                    {
19817                                                      if (((word >> 29) & 0x1) == 0)
19818                                                        {
19819                                                          /* 33222222222211111111110000000000
19820                                                             10987654321098765432109876543210
19821                                                             xx0011101x1xxxxx110101xxxxxxxxxx
19822                                                             fsub.  */
19823                                                          return 311;
19824                                                        }
19825                                                      else
19826                                                        {
19827                                                          /* 33222222222211111111110000000000
19828                                                             10987654321098765432109876543210
19829                                                             xx1011101x1xxxxx110101xxxxxxxxxx
19830                                                             fabd.  */
19831                                                          return 360;
19832                                                        }
19833                                                    }
19834                                                }
19835                                            }
19836                                          else
19837                                            {
19838                                              if (((word >> 14) & 0x1) == 0)
19839                                                {
19840                                                  if (((word >> 29) & 0x1) == 0)
19841                                                    {
19842                                                      /* 33222222222211111111110000000000
19843                                                         10987654321098765432109876543210
19844                                                         xx001110xx1xxxxx101101xxxxxxxxxx
19845                                                         sqdmulh.  */
19846                                                      return 289;
19847                                                    }
19848                                                  else
19849                                                    {
19850                                                      /* 33222222222211111111110000000000
19851                                                         10987654321098765432109876543210
19852                                                         xx101110xx1xxxxx101101xxxxxxxxxx
19853                                                         sqrdmulh.  */
19854                                                      return 341;
19855                                                    }
19856                                                }
19857                                              else
19858                                                {
19859                                                  if (((word >> 23) & 0x1) == 0)
19860                                                    {
19861                                                      if (((word >> 29) & 0x1) == 0)
19862                                                        {
19863                                                          /* 33222222222211111111110000000000
19864                                                             10987654321098765432109876543210
19865                                                             xx0011100x1xxxxx111101xxxxxxxxxx
19866                                                             fmax.  */
19867                                                          return 301;
19868                                                        }
19869                                                      else
19870                                                        {
19871                                                          /* 33222222222211111111110000000000
19872                                                             10987654321098765432109876543210
19873                                                             xx1011100x1xxxxx111101xxxxxxxxxx
19874                                                             fmaxp.  */
19875                                                          return 352;
19876                                                        }
19877                                                    }
19878                                                  else
19879                                                    {
19880                                                      if (((word >> 29) & 0x1) == 0)
19881                                                        {
19882                                                          /* 33222222222211111111110000000000
19883                                                             10987654321098765432109876543210
19884                                                             xx0011101x1xxxxx111101xxxxxxxxxx
19885                                                             fmin.  */
19886                                                          return 313;
19887                                                        }
19888                                                      else
19889                                                        {
19890                                                          /* 33222222222211111111110000000000
19891                                                             10987654321098765432109876543210
19892                                                             xx1011101x1xxxxx111101xxxxxxxxxx
19893                                                             fminp.  */
19894                                                          return 366;
19895                                                        }
19896                                                    }
19897                                                }
19898                                            }
19899                                        }
19900                                    }
19901                                  else
19902                                    {
19903                                      if (((word >> 12) & 0x1) == 0)
19904                                        {
19905                                          if (((word >> 13) & 0x1) == 0)
19906                                            {
19907                                              if (((word >> 14) & 0x1) == 0)
19908                                                {
19909                                                  if (((word >> 29) & 0x1) == 0)
19910                                                    {
19911                                                      if (((word >> 31) & 0x1) == 0)
19912                                                        {
19913                                                          /* 33222222222211111111110000000000
19914                                                             10987654321098765432109876543210
19915                                                             0x001110xx1xxxxx100011xxxxxxxxxx
19916                                                             cmtst.  */
19917                                                          return 284;
19918                                                        }
19919                                                      else
19920                                                        {
19921                                                          /* 33222222222211111111110000000000
19922                                                             10987654321098765432109876543210
19923                                                             1x001110xx1xxxxx100011xxxxxxxxxx
19924                                                             rax1.  */
19925                                                          return 2346;
19926                                                        }
19927                                                    }
19928                                                  else
19929                                                    {
19930                                                      /* 33222222222211111111110000000000
19931                                                         10987654321098765432109876543210
19932                                                         xx101110xx1xxxxx100011xxxxxxxxxx
19933                                                         cmeq.  */
19934                                                      return 336;
19935                                                    }
19936                                                }
19937                                              else
19938                                                {
19939                                                  if (((word >> 23) & 0x1) == 0)
19940                                                    {
19941                                                      if (((word >> 29) & 0x1) == 0)
19942                                                        {
19943                                                          /* 33222222222211111111110000000000
19944                                                             10987654321098765432109876543210
19945                                                             xx0011100x1xxxxx110011xxxxxxxxxx
19946                                                             fmla.  */
19947                                                          return 293;
19948                                                        }
19949                                                      else
19950                                                        {
19951                                                          if (((word >> 30) & 0x1) == 0)
19952                                                            {
19953                                                              /* 33222222222211111111110000000000
19954                                                                 10987654321098765432109876543210
19955                                                                 x01011100x1xxxxx110011xxxxxxxxxx
19956                                                                 fmlal2.  */
19957                                                              return 2360;
19958                                                            }
19959                                                          else
19960                                                            {
19961                                                              /* 33222222222211111111110000000000
19962                                                                 10987654321098765432109876543210
19963                                                                 x11011100x1xxxxx110011xxxxxxxxxx
19964                                                                 fmlal2.  */
19965                                                              return 2364;
19966                                                            }
19967                                                        }
19968                                                    }
19969                                                  else
19970                                                    {
19971                                                      if (((word >> 29) & 0x1) == 0)
19972                                                        {
19973                                                          /* 33222222222211111111110000000000
19974                                                             10987654321098765432109876543210
19975                                                             xx0011101x1xxxxx110011xxxxxxxxxx
19976                                                             fmls.  */
19977                                                          return 309;
19978                                                        }
19979                                                      else
19980                                                        {
19981                                                          if (((word >> 30) & 0x1) == 0)
19982                                                            {
19983                                                              /* 33222222222211111111110000000000
19984                                                                 10987654321098765432109876543210
19985                                                                 x01011101x1xxxxx110011xxxxxxxxxx
19986                                                                 fmlsl2.  */
19987                                                              return 2361;
19988                                                            }
19989                                                          else
19990                                                            {
19991                                                              /* 33222222222211111111110000000000
19992                                                                 10987654321098765432109876543210
19993                                                                 x11011101x1xxxxx110011xxxxxxxxxx
19994                                                                 fmlsl2.  */
19995                                                              return 2365;
19996                                                            }
19997                                                        }
19998                                                    }
19999                                                }
20000                                            }
20001                                          else
20002                                            {
20003                                              if (((word >> 14) & 0x1) == 0)
20004                                                {
20005                                                  if (((word >> 29) & 0x1) == 0)
20006                                                    {
20007                                                      /* 33222222222211111111110000000000
20008                                                         10987654321098765432109876543210
20009                                                         xx001110xx1xxxxx101011xxxxxxxxxx
20010                                                         sminp.  */
20011                                                      return 288;
20012                                                    }
20013                                                  else
20014                                                    {
20015                                                      /* 33222222222211111111110000000000
20016                                                         10987654321098765432109876543210
20017                                                         xx101110xx1xxxxx101011xxxxxxxxxx
20018                                                         uminp.  */
20019                                                      return 340;
20020                                                    }
20021                                                }
20022                                              else
20023                                                {
20024                                                  if (((word >> 23) & 0x1) == 0)
20025                                                    {
20026                                                      if (((word >> 29) & 0x1) == 0)
20027                                                        {
20028                                                          if (((word >> 30) & 0x1) == 0)
20029                                                            {
20030                                                              /* 33222222222211111111110000000000
20031                                                                 10987654321098765432109876543210
20032                                                                 x00011100x1xxxxx111011xxxxxxxxxx
20033                                                                 fmlal.  */
20034                                                              return 2358;
20035                                                            }
20036                                                          else
20037                                                            {
20038                                                              /* 33222222222211111111110000000000
20039                                                                 10987654321098765432109876543210
20040                                                                 x10011100x1xxxxx111011xxxxxxxxxx
20041                                                                 fmlal.  */
20042                                                              return 2362;
20043                                                            }
20044                                                        }
20045                                                      else
20046                                                        {
20047                                                          /* 33222222222211111111110000000000
20048                                                             10987654321098765432109876543210
20049                                                             xx1011100x1xxxxx111011xxxxxxxxxx
20050                                                             facge.  */
20051                                                          return 350;
20052                                                        }
20053                                                    }
20054                                                  else
20055                                                    {
20056                                                      if (((word >> 29) & 0x1) == 0)
20057                                                        {
20058                                                          if (((word >> 30) & 0x1) == 0)
20059                                                            {
20060                                                              /* 33222222222211111111110000000000
20061                                                                 10987654321098765432109876543210
20062                                                                 x00011101x1xxxxx111011xxxxxxxxxx
20063                                                                 fmlsl.  */
20064                                                              return 2359;
20065                                                            }
20066                                                          else
20067                                                            {
20068                                                              /* 33222222222211111111110000000000
20069                                                                 10987654321098765432109876543210
20070                                                                 x10011101x1xxxxx111011xxxxxxxxxx
20071                                                                 fmlsl.  */
20072                                                              return 2363;
20073                                                            }
20074                                                        }
20075                                                      else
20076                                                        {
20077                                                          /* 33222222222211111111110000000000
20078                                                             10987654321098765432109876543210
20079                                                             xx1011101x1xxxxx111011xxxxxxxxxx
20080                                                             facgt.  */
20081                                                          return 364;
20082                                                        }
20083                                                    }
20084                                                }
20085                                            }
20086                                        }
20087                                      else
20088                                        {
20089                                          if (((word >> 13) & 0x1) == 0)
20090                                            {
20091                                              if (((word >> 14) & 0x1) == 0)
20092                                                {
20093                                                  if (((word >> 29) & 0x1) == 0)
20094                                                    {
20095                                                      /* 33222222222211111111110000000000
20096                                                         10987654321098765432109876543210
20097                                                         xx001110xx1xxxxx100111xxxxxxxxxx
20098                                                         mul.  */
20099                                                      return 286;
20100                                                    }
20101                                                  else
20102                                                    {
20103                                                      /* 33222222222211111111110000000000
20104                                                         10987654321098765432109876543210
20105                                                         xx101110xx1xxxxx100111xxxxxxxxxx
20106                                                         pmul.  */
20107                                                      return 338;
20108                                                    }
20109                                                }
20110                                              else
20111                                                {
20112                                                  if (((word >> 29) & 0x1) == 0)
20113                                                    {
20114                                                      /* 33222222222211111111110000000000
20115                                                         10987654321098765432109876543210
20116                                                         xx001110xx1xxxxx110111xxxxxxxxxx
20117                                                         fmulx.  */
20118                                                      return 297;
20119                                                    }
20120                                                  else
20121                                                    {
20122                                                      /* 33222222222211111111110000000000
20123                                                         10987654321098765432109876543210
20124                                                         xx101110xx1xxxxx110111xxxxxxxxxx
20125                                                         fmul.  */
20126                                                      return 346;
20127                                                    }
20128                                                }
20129                                            }
20130                                          else
20131                                            {
20132                                              if (((word >> 14) & 0x1) == 0)
20133                                                {
20134                                                  /* 33222222222211111111110000000000
20135                                                     10987654321098765432109876543210
20136                                                     xxx01110xx1xxxxx101111xxxxxxxxxx
20137                                                     addp.  */
20138                                                  return 290;
20139                                                }
20140                                              else
20141                                                {
20142                                                  if (((word >> 23) & 0x1) == 0)
20143                                                    {
20144                                                      if (((word >> 29) & 0x1) == 0)
20145                                                        {
20146                                                          /* 33222222222211111111110000000000
20147                                                             10987654321098765432109876543210
20148                                                             xx0011100x1xxxxx111111xxxxxxxxxx
20149                                                             frecps.  */
20150                                                          return 303;
20151                                                        }
20152                                                      else
20153                                                        {
20154                                                          /* 33222222222211111111110000000000
20155                                                             10987654321098765432109876543210
20156                                                             xx1011100x1xxxxx111111xxxxxxxxxx
20157                                                             fdiv.  */
20158                                                          return 354;
20159                                                        }
20160                                                    }
20161                                                  else
20162                                                    {
20163                                                      /* 33222222222211111111110000000000
20164                                                         10987654321098765432109876543210
20165                                                         xxx011101x1xxxxx111111xxxxxxxxxx
20166                                                         frsqrts.  */
20167                                                      return 315;
20168                                                    }
20169                                                }
20170                                            }
20171                                        }
20172                                    }
20173                                }
20174                            }
20175                        }
20176                      else
20177                        {
20178                          if (((word >> 10) & 0x1) == 0)
20179                            {
20180                              if (((word >> 11) & 0x1) == 0)
20181                                {
20182                                  if (((word >> 12) & 0x1) == 0)
20183                                    {
20184                                      if (((word >> 13) & 0x1) == 0)
20185                                        {
20186                                          if (((word >> 14) & 0x1) == 0)
20187                                            {
20188                                              if (((word >> 16) & 0x1) == 0)
20189                                                {
20190                                                  if (((word >> 17) & 0x1) == 0)
20191                                                    {
20192                                                      if (((word >> 18) & 0x1) == 0)
20193                                                        {
20194                                                          if (((word >> 19) & 0x1) == 0)
20195                                                            {
20196                                                              if (((word >> 20) & 0x1) == 0)
20197                                                                {
20198                                                                  /* 33222222222211111111110000000000
20199                                                                     10987654321098765432109876543210
20200                                                                     xxx11110xx100000x00000xxxxxxxxxx
20201                                                                     fcvtns.  */
20202                                                                  return 767;
20203                                                                }
20204                                                              else
20205                                                                {
20206                                                                  /* 33222222222211111111110000000000
20207                                                                     10987654321098765432109876543210
20208                                                                     xxx11110xx110000x00000xxxxxxxxxx
20209                                                                     fcvtms.  */
20210                                                                  return 787;
20211                                                                }
20212                                                            }
20213                                                          else
20214                                                            {
20215                                                              if (((word >> 20) & 0x1) == 0)
20216                                                                {
20217                                                                  /* 33222222222211111111110000000000
20218                                                                     10987654321098765432109876543210
20219                                                                     xxx11110xx101000x00000xxxxxxxxxx
20220                                                                     fcvtps.  */
20221                                                                  return 783;
20222                                                                }
20223                                                              else
20224                                                                {
20225                                                                  /* 33222222222211111111110000000000
20226                                                                     10987654321098765432109876543210
20227                                                                     xxx11110xx111000x00000xxxxxxxxxx
20228                                                                     fcvtzs.  */
20229                                                                  return 791;
20230                                                                }
20231                                                            }
20232                                                        }
20233                                                      else
20234                                                        {
20235                                                          /* 33222222222211111111110000000000
20236                                                             10987654321098765432109876543210
20237                                                             xxx11110xx1xx100x00000xxxxxxxxxx
20238                                                             fcvtas.  */
20239                                                          return 775;
20240                                                        }
20241                                                    }
20242                                                  else
20243                                                    {
20244                                                      if (((word >> 18) & 0x1) == 0)
20245                                                        {
20246                                                          /* 33222222222211111111110000000000
20247                                                             10987654321098765432109876543210
20248                                                             xxx11110xx1xx010x00000xxxxxxxxxx
20249                                                             scvtf.  */
20250                                                          return 771;
20251                                                        }
20252                                                      else
20253                                                        {
20254                                                          if (((word >> 19) & 0x1) == 0)
20255                                                            {
20256                                                              /* 33222222222211111111110000000000
20257                                                                 10987654321098765432109876543210
20258                                                                 xxx11110xx1x0110x00000xxxxxxxxxx
20259                                                                 fmov.  */
20260                                                              return 779;
20261                                                            }
20262                                                          else
20263                                                            {
20264                                                              if (((word >> 20) & 0x1) == 0)
20265                                                                {
20266                                                                  /* 33222222222211111111110000000000
20267                                                                     10987654321098765432109876543210
20268                                                                     xxx11110xx101110x00000xxxxxxxxxx
20269                                                                     fmov.  */
20270                                                                  return 795;
20271                                                                }
20272                                                              else
20273                                                                {
20274                                                                  /* 33222222222211111111110000000000
20275                                                                     10987654321098765432109876543210
20276                                                                     xxx11110xx111110x00000xxxxxxxxxx
20277                                                                     fjcvtzs.  */
20278                                                                  return 797;
20279                                                                }
20280                                                            }
20281                                                        }
20282                                                    }
20283                                                }
20284                                              else
20285                                                {
20286                                                  if (((word >> 17) & 0x1) == 0)
20287                                                    {
20288                                                      if (((word >> 18) & 0x1) == 0)
20289                                                        {
20290                                                          if (((word >> 19) & 0x1) == 0)
20291                                                            {
20292                                                              if (((word >> 20) & 0x1) == 0)
20293                                                                {
20294                                                                  /* 33222222222211111111110000000000
20295                                                                     10987654321098765432109876543210
20296                                                                     xxx11110xx100001x00000xxxxxxxxxx
20297                                                                     fcvtnu.  */
20298                                                                  return 769;
20299                                                                }
20300                                                              else
20301                                                                {
20302                                                                  /* 33222222222211111111110000000000
20303                                                                     10987654321098765432109876543210
20304                                                                     xxx11110xx110001x00000xxxxxxxxxx
20305                                                                     fcvtmu.  */
20306                                                                  return 789;
20307                                                                }
20308                                                            }
20309                                                          else
20310                                                            {
20311                                                              if (((word >> 20) & 0x1) == 0)
20312                                                                {
20313                                                                  /* 33222222222211111111110000000000
20314                                                                     10987654321098765432109876543210
20315                                                                     xxx11110xx101001x00000xxxxxxxxxx
20316                                                                     fcvtpu.  */
20317                                                                  return 785;
20318                                                                }
20319                                                              else
20320                                                                {
20321                                                                  /* 33222222222211111111110000000000
20322                                                                     10987654321098765432109876543210
20323                                                                     xxx11110xx111001x00000xxxxxxxxxx
20324                                                                     fcvtzu.  */
20325                                                                  return 793;
20326                                                                }
20327                                                            }
20328                                                        }
20329                                                      else
20330                                                        {
20331                                                          /* 33222222222211111111110000000000
20332                                                             10987654321098765432109876543210
20333                                                             xxx11110xx1xx101x00000xxxxxxxxxx
20334                                                             fcvtau.  */
20335                                                          return 777;
20336                                                        }
20337                                                    }
20338                                                  else
20339                                                    {
20340                                                      if (((word >> 18) & 0x1) == 0)
20341                                                        {
20342                                                          /* 33222222222211111111110000000000
20343                                                             10987654321098765432109876543210
20344                                                             xxx11110xx1xx011x00000xxxxxxxxxx
20345                                                             ucvtf.  */
20346                                                          return 773;
20347                                                        }
20348                                                      else
20349                                                        {
20350                                                          if (((word >> 19) & 0x1) == 0)
20351                                                            {
20352                                                              /* 33222222222211111111110000000000
20353                                                                 10987654321098765432109876543210
20354                                                                 xxx11110xx1x0111x00000xxxxxxxxxx
20355                                                                 fmov.  */
20356                                                              return 781;
20357                                                            }
20358                                                          else
20359                                                            {
20360                                                              /* 33222222222211111111110000000000
20361                                                                 10987654321098765432109876543210
20362                                                                 xxx11110xx1x1111x00000xxxxxxxxxx
20363                                                                 fmov.  */
20364                                                              return 796;
20365                                                            }
20366                                                        }
20367                                                    }
20368                                                }
20369                                            }
20370                                          else
20371                                            {
20372                                              if (((word >> 17) & 0x1) == 0)
20373                                                {
20374                                                  if (((word >> 15) & 0x1) == 0)
20375                                                    {
20376                                                      if (((word >> 16) & 0x1) == 0)
20377                                                        {
20378                                                          if (((word >> 18) & 0x1) == 0)
20379                                                            {
20380                                                              if (((word >> 19) & 0x1) == 0)
20381                                                                {
20382                                                                  /* 33222222222211111111110000000000
20383                                                                     10987654321098765432109876543210
20384                                                                     xxx11110xx1x0000010000xxxxxxxxxx
20385                                                                     fmov.  */
20386                                                                  return 816;
20387                                                                }
20388                                                              else
20389                                                                {
20390                                                                  /* 33222222222211111111110000000000
20391                                                                     10987654321098765432109876543210
20392                                                                     xxx11110xx1x1000010000xxxxxxxxxx
20393                                                                     frint32z.  */
20394                                                                  return 812;
20395                                                                }
20396                                                            }
20397                                                          else
20398                                                            {
20399                                                              /* 33222222222211111111110000000000
20400                                                                 10987654321098765432109876543210
20401                                                                 xxx11110xx1xx100010000xxxxxxxxxx
20402                                                                 frintn.  */
20403                                                              return 825;
20404                                                            }
20405                                                        }
20406                                                      else
20407                                                        {
20408                                                          if (((word >> 18) & 0x1) == 0)
20409                                                            {
20410                                                              if (((word >> 19) & 0x1) == 0)
20411                                                                {
20412                                                                  /* 33222222222211111111110000000000
20413                                                                     10987654321098765432109876543210
20414                                                                     xxx11110xx1x0001010000xxxxxxxxxx
20415                                                                     fneg.  */
20416                                                                  return 820;
20417                                                                }
20418                                                              else
20419                                                                {
20420                                                                  /* 33222222222211111111110000000000
20421                                                                     10987654321098765432109876543210
20422                                                                     xxx11110xx1x1001010000xxxxxxxxxx
20423                                                                     frint64z.  */
20424                                                                  return 814;
20425                                                                }
20426                                                            }
20427                                                          else
20428                                                            {
20429                                                              /* 33222222222211111111110000000000
20430                                                                 10987654321098765432109876543210
20431                                                                 xxx11110xx1xx101010000xxxxxxxxxx
20432                                                                 frintm.  */
20433                                                              return 829;
20434                                                            }
20435                                                        }
20436                                                    }
20437                                                  else
20438                                                    {
20439                                                      if (((word >> 16) & 0x1) == 0)
20440                                                        {
20441                                                          if (((word >> 18) & 0x1) == 0)
20442                                                            {
20443                                                              if (((word >> 19) & 0x1) == 0)
20444                                                                {
20445                                                                  /* 33222222222211111111110000000000
20446                                                                     10987654321098765432109876543210
20447                                                                     xxx11110xx1x0000110000xxxxxxxxxx
20448                                                                     fabs.  */
20449                                                                  return 818;
20450                                                                }
20451                                                              else
20452                                                                {
20453                                                                  /* 33222222222211111111110000000000
20454                                                                     10987654321098765432109876543210
20455                                                                     xxx11110xx1x1000110000xxxxxxxxxx
20456                                                                     frint32x.  */
20457                                                                  return 813;
20458                                                                }
20459                                                            }
20460                                                          else
20461                                                            {
20462                                                              /* 33222222222211111111110000000000
20463                                                                 10987654321098765432109876543210
20464                                                                 xxx11110xx1xx100110000xxxxxxxxxx
20465                                                                 frintp.  */
20466                                                              return 827;
20467                                                            }
20468                                                        }
20469                                                      else
20470                                                        {
20471                                                          if (((word >> 18) & 0x1) == 0)
20472                                                            {
20473                                                              if (((word >> 19) & 0x1) == 0)
20474                                                                {
20475                                                                  /* 33222222222211111111110000000000
20476                                                                     10987654321098765432109876543210
20477                                                                     xxx11110xx1x0001110000xxxxxxxxxx
20478                                                                     fsqrt.  */
20479                                                                  return 822;
20480                                                                }
20481                                                              else
20482                                                                {
20483                                                                  /* 33222222222211111111110000000000
20484                                                                     10987654321098765432109876543210
20485                                                                     xxx11110xx1x1001110000xxxxxxxxxx
20486                                                                     frint64x.  */
20487                                                                  return 815;
20488                                                                }
20489                                                            }
20490                                                          else
20491                                                            {
20492                                                              /* 33222222222211111111110000000000
20493                                                                 10987654321098765432109876543210
20494                                                                 xxx11110xx1xx101110000xxxxxxxxxx
20495                                                                 frintz.  */
20496                                                              return 831;
20497                                                            }
20498                                                        }
20499                                                    }
20500                                                }
20501                                              else
20502                                                {
20503                                                  if (((word >> 18) & 0x1) == 0)
20504                                                    {
20505                                                      /* 33222222222211111111110000000000
20506                                                         10987654321098765432109876543210
20507                                                         xxx11110xx1xx01xx10000xxxxxxxxxx
20508                                                         fcvt.  */
20509                                                      return 824;
20510                                                    }
20511                                                  else
20512                                                    {
20513                                                      if (((word >> 15) & 0x1) == 0)
20514                                                        {
20515                                                          if (((word >> 16) & 0x1) == 0)
20516                                                            {
20517                                                              /* 33222222222211111111110000000000
20518                                                                 10987654321098765432109876543210
20519                                                                 xxx11110xx1xx110010000xxxxxxxxxx
20520                                                                 frinta.  */
20521                                                              return 833;
20522                                                            }
20523                                                          else
20524                                                            {
20525                                                              /* 33222222222211111111110000000000
20526                                                                 10987654321098765432109876543210
20527                                                                 xxx11110xx1xx111010000xxxxxxxxxx
20528                                                                 frintx.  */
20529                                                              return 835;
20530                                                            }
20531                                                        }
20532                                                      else
20533                                                        {
20534                                                          /* 33222222222211111111110000000000
20535                                                             10987654321098765432109876543210
20536                                                             xxx11110xx1xx11x110000xxxxxxxxxx
20537                                                             frinti.  */
20538                                                          return 837;
20539                                                        }
20540                                                    }
20541                                                }
20542                                            }
20543                                        }
20544                                      else
20545                                        {
20546                                          if (((word >> 3) & 0x1) == 0)
20547                                            {
20548                                              if (((word >> 4) & 0x1) == 0)
20549                                                {
20550                                                  /* 33222222222211111111110000000000
20551                                                     10987654321098765432109876543210
20552                                                     xxx11110xx1xxxxxxx1000xxxxx00xxx
20553                                                     fcmp.  */
20554                                                  return 802;
20555                                                }
20556                                              else
20557                                                {
20558                                                  /* 33222222222211111111110000000000
20559                                                     10987654321098765432109876543210
20560                                                     xxx11110xx1xxxxxxx1000xxxxx10xxx
20561                                                     fcmpe.  */
20562                                                  return 804;
20563                                                }
20564                                            }
20565                                          else
20566                                            {
20567                                              if (((word >> 4) & 0x1) == 0)
20568                                                {
20569                                                  /* 33222222222211111111110000000000
20570                                                     10987654321098765432109876543210
20571                                                     xxx11110xx1xxxxxxx1000xxxxx01xxx
20572                                                     fcmp.  */
20573                                                  return 806;
20574                                                }
20575                                              else
20576                                                {
20577                                                  /* 33222222222211111111110000000000
20578                                                     10987654321098765432109876543210
20579                                                     xxx11110xx1xxxxxxx1000xxxxx11xxx
20580                                                     fcmpe.  */
20581                                                  return 808;
20582                                                }
20583                                            }
20584                                        }
20585                                    }
20586                                  else
20587                                    {
20588                                      if (((word >> 30) & 0x1) == 0)
20589                                        {
20590                                          /* 33222222222211111111110000000000
20591                                             10987654321098765432109876543210
20592                                             x0x11110xx1xxxxxxxx100xxxxxxxxxx
20593                                             fmov.  */
20594                                          return 865;
20595                                        }
20596                                      else
20597                                        {
20598                                          if (((word >> 13) & 0x1) == 0)
20599                                            {
20600                                              if (((word >> 14) & 0x1) == 0)
20601                                                {
20602                                                  /* 33222222222211111111110000000000
20603                                                     10987654321098765432109876543210
20604                                                     x1x11110xx1xxxxxx00100xxxxxxxxxx
20605                                                     sqdmlal.  */
20606                                                  return 422;
20607                                                }
20608                                              else
20609                                                {
20610                                                  /* 33222222222211111111110000000000
20611                                                     10987654321098765432109876543210
20612                                                     x1x11110xx1xxxxxx10100xxxxxxxxxx
20613                                                     sqdmull.  */
20614                                                  return 424;
20615                                                }
20616                                            }
20617                                          else
20618                                            {
20619                                              /* 33222222222211111111110000000000
20620                                                 10987654321098765432109876543210
20621                                                 x1x11110xx1xxxxxxx1100xxxxxxxxxx
20622                                                 sqdmlsl.  */
20623                                              return 423;
20624                                            }
20625                                        }
20626                                    }
20627                                }
20628                              else
20629                                {
20630                                  if (((word >> 12) & 0x1) == 0)
20631                                    {
20632                                      if (((word >> 13) & 0x1) == 0)
20633                                        {
20634                                          if (((word >> 14) & 0x1) == 0)
20635                                            {
20636                                              if (((word >> 15) & 0x1) == 0)
20637                                                {
20638                                                  if (((word >> 30) & 0x1) == 0)
20639                                                    {
20640                                                      /* 33222222222211111111110000000000
20641                                                         10987654321098765432109876543210
20642                                                         x0x11110xx1xxxxx000010xxxxxxxxxx
20643                                                         fmul.  */
20644                                                      return 839;
20645                                                    }
20646                                                  else
20647                                                    {
20648                                                      /* 33222222222211111111110000000000
20649                                                         10987654321098765432109876543210
20650                                                         x1x11110xx1xxxxx000010xxxxxxxxxx
20651                                                         sha1h.  */
20652                                                      return 675;
20653                                                    }
20654                                                }
20655                                              else
20656                                                {
20657                                                  if (((word >> 29) & 0x1) == 0)
20658                                                    {
20659                                                      if (((word >> 30) & 0x1) == 0)
20660                                                        {
20661                                                          /* 33222222222211111111110000000000
20662                                                             10987654321098765432109876543210
20663                                                             x0011110xx1xxxxx100010xxxxxxxxxx
20664                                                             fnmul.  */
20665                                                          return 855;
20666                                                        }
20667                                                      else
20668                                                        {
20669                                                          /* 33222222222211111111110000000000
20670                                                             10987654321098765432109876543210
20671                                                             x1011110xx1xxxxx100010xxxxxxxxxx
20672                                                             cmgt.  */
20673                                                          return 482;
20674                                                        }
20675                                                    }
20676                                                  else
20677                                                    {
20678                                                      /* 33222222222211111111110000000000
20679                                                         10987654321098765432109876543210
20680                                                         xx111110xx1xxxxx100010xxxxxxxxxx
20681                                                         cmge.  */
20682                                                      return 511;
20683                                                    }
20684                                                }
20685                                            }
20686                                          else
20687                                            {
20688                                              if (((word >> 15) & 0x1) == 0)
20689                                                {
20690                                                  if (((word >> 29) & 0x1) == 0)
20691                                                    {
20692                                                      if (((word >> 30) & 0x1) == 0)
20693                                                        {
20694                                                          /* 33222222222211111111110000000000
20695                                                             10987654321098765432109876543210
20696                                                             x0011110xx1xxxxx010010xxxxxxxxxx
20697                                                             fmax.  */
20698                                                          return 847;
20699                                                        }
20700                                                      else
20701                                                        {
20702                                                          /* 33222222222211111111110000000000
20703                                                             10987654321098765432109876543210
20704                                                             x1011110xx1xxxxx010010xxxxxxxxxx
20705                                                             sqxtn.  */
20706                                                          return 486;
20707                                                        }
20708                                                    }
20709                                                  else
20710                                                    {
20711                                                      /* 33222222222211111111110000000000
20712                                                         10987654321098765432109876543210
20713                                                         xx111110xx1xxxxx010010xxxxxxxxxx
20714                                                         uqxtn.  */
20715                                                      return 515;
20716                                                    }
20717                                                }
20718                                              else
20719                                                {
20720                                                  if (((word >> 16) & 0x1) == 0)
20721                                                    {
20722                                                      if (((word >> 19) & 0x1) == 0)
20723                                                        {
20724                                                          if (((word >> 20) & 0x1) == 0)
20725                                                            {
20726                                                              if (((word >> 29) & 0x1) == 0)
20727                                                                {
20728                                                                  /* 33222222222211111111110000000000
20729                                                                     10987654321098765432109876543210
20730                                                                     xx011110xx100xx0110010xxxxxxxxxx
20731                                                                     fcmgt.  */
20732                                                                  return 495;
20733                                                                }
20734                                                              else
20735                                                                {
20736                                                                  /* 33222222222211111111110000000000
20737                                                                     10987654321098765432109876543210
20738                                                                     xx111110xx100xx0110010xxxxxxxxxx
20739                                                                     fcmge.  */
20740                                                                  return 525;
20741                                                                }
20742                                                            }
20743                                                          else
20744                                                            {
20745                                                              if (((word >> 23) & 0x1) == 0)
20746                                                                {
20747                                                                  if (((word >> 29) & 0x1) == 0)
20748                                                                    {
20749                                                                      /* 33222222222211111111110000000000
20750                                                                         10987654321098765432109876543210
20751                                                                         xx0111100x110xx0110010xxxxxxxxxx
20752                                                                         fmaxnmp.  */
20753                                                                      return 539;
20754                                                                    }
20755                                                                  else
20756                                                                    {
20757                                                                      /* 33222222222211111111110000000000
20758                                                                         10987654321098765432109876543210
20759                                                                         xx1111100x110xx0110010xxxxxxxxxx
20760                                                                         fmaxnmp.  */
20761                                                                      return 538;
20762                                                                    }
20763                                                                }
20764                                                              else
20765                                                                {
20766                                                                  if (((word >> 29) & 0x1) == 0)
20767                                                                    {
20768                                                                      /* 33222222222211111111110000000000
20769                                                                         10987654321098765432109876543210
20770                                                                         xx0111101x110xx0110010xxxxxxxxxx
20771                                                                         fminnmp.  */
20772                                                                      return 545;
20773                                                                    }
20774                                                                  else
20775                                                                    {
20776                                                                      /* 33222222222211111111110000000000
20777                                                                         10987654321098765432109876543210
20778                                                                         xx1111101x110xx0110010xxxxxxxxxx
20779                                                                         fminnmp.  */
20780                                                                      return 544;
20781                                                                    }
20782                                                                }
20783                                                            }
20784                                                        }
20785                                                      else
20786                                                        {
20787                                                          if (((word >> 29) & 0x1) == 0)
20788                                                            {
20789                                                              /* 33222222222211111111110000000000
20790                                                                 10987654321098765432109876543210
20791                                                                 xx011110xx1x1xx0110010xxxxxxxxxx
20792                                                                 fcmgt.  */
20793                                                              return 496;
20794                                                            }
20795                                                          else
20796                                                            {
20797                                                              /* 33222222222211111111110000000000
20798                                                                 10987654321098765432109876543210
20799                                                                 xx111110xx1x1xx0110010xxxxxxxxxx
20800                                                                 fcmge.  */
20801                                                              return 526;
20802                                                            }
20803                                                        }
20804                                                    }
20805                                                  else
20806                                                    {
20807                                                      if (((word >> 19) & 0x1) == 0)
20808                                                        {
20809                                                          if (((word >> 29) & 0x1) == 0)
20810                                                            {
20811                                                              /* 33222222222211111111110000000000
20812                                                                 10987654321098765432109876543210
20813                                                                 xx011110xx1x0xx1110010xxxxxxxxxx
20814                                                                 fcvtas.  */
20815                                                              return 491;
20816                                                            }
20817                                                          else
20818                                                            {
20819                                                              /* 33222222222211111111110000000000
20820                                                                 10987654321098765432109876543210
20821                                                                 xx111110xx1x0xx1110010xxxxxxxxxx
20822                                                                 fcvtau.  */
20823                                                              return 521;
20824                                                            }
20825                                                        }
20826                                                      else
20827                                                        {
20828                                                          if (((word >> 29) & 0x1) == 0)
20829                                                            {
20830                                                              /* 33222222222211111111110000000000
20831                                                                 10987654321098765432109876543210
20832                                                                 xx011110xx1x1xx1110010xxxxxxxxxx
20833                                                                 fcvtas.  */
20834                                                              return 492;
20835                                                            }
20836                                                          else
20837                                                            {
20838                                                              /* 33222222222211111111110000000000
20839                                                                 10987654321098765432109876543210
20840                                                                 xx111110xx1x1xx1110010xxxxxxxxxx
20841                                                                 fcvtau.  */
20842                                                              return 522;
20843                                                            }
20844                                                        }
20845                                                    }
20846                                                }
20847                                            }
20848                                        }
20849                                      else
20850                                        {
20851                                          if (((word >> 14) & 0x1) == 0)
20852                                            {
20853                                              if (((word >> 15) & 0x1) == 0)
20854                                                {
20855                                                  if (((word >> 29) & 0x1) == 0)
20856                                                    {
20857                                                      if (((word >> 30) & 0x1) == 0)
20858                                                        {
20859                                                          /* 33222222222211111111110000000000
20860                                                             10987654321098765432109876543210
20861                                                             x0011110xx1xxxxx001010xxxxxxxxxx
20862                                                             fadd.  */
20863                                                          return 843;
20864                                                        }
20865                                                      else
20866                                                        {
20867                                                          /* 33222222222211111111110000000000
20868                                                             10987654321098765432109876543210
20869                                                             x1011110xx1xxxxx001010xxxxxxxxxx
20870                                                             sha256su0.  */
20871                                                          return 677;
20872                                                        }
20873                                                    }
20874                                                  else
20875                                                    {
20876                                                      /* 33222222222211111111110000000000
20877                                                         10987654321098765432109876543210
20878                                                         xx111110xx1xxxxx001010xxxxxxxxxx
20879                                                         sqxtun.  */
20880                                                      return 514;
20881                                                    }
20882                                                }
20883                                              else
20884                                                {
20885                                                  if (((word >> 16) & 0x1) == 0)
20886                                                    {
20887                                                      /* 33222222222211111111110000000000
20888                                                         10987654321098765432109876543210
20889                                                         xxx11110xx1xxxx0101010xxxxxxxxxx
20890                                                         cmlt.  */
20891                                                      return 484;
20892                                                    }
20893                                                  else
20894                                                    {
20895                                                      if (((word >> 19) & 0x1) == 0)
20896                                                        {
20897                                                          if (((word >> 23) & 0x1) == 0)
20898                                                            {
20899                                                              if (((word >> 29) & 0x1) == 0)
20900                                                                {
20901                                                                  /* 33222222222211111111110000000000
20902                                                                     10987654321098765432109876543210
20903                                                                     xx0111100x1x0xx1101010xxxxxxxxxx
20904                                                                     fcvtns.  */
20905                                                                  return 487;
20906                                                                }
20907                                                              else
20908                                                                {
20909                                                                  /* 33222222222211111111110000000000
20910                                                                     10987654321098765432109876543210
20911                                                                     xx1111100x1x0xx1101010xxxxxxxxxx
20912                                                                     fcvtnu.  */
20913                                                                  return 517;
20914                                                                }
20915                                                            }
20916                                                          else
20917                                                            {
20918                                                              if (((word >> 29) & 0x1) == 0)
20919                                                                {
20920                                                                  /* 33222222222211111111110000000000
20921                                                                     10987654321098765432109876543210
20922                                                                     xx0111101x1x0xx1101010xxxxxxxxxx
20923                                                                     fcvtps.  */
20924                                                                  return 501;
20925                                                                }
20926                                                              else
20927                                                                {
20928                                                                  /* 33222222222211111111110000000000
20929                                                                     10987654321098765432109876543210
20930                                                                     xx1111101x1x0xx1101010xxxxxxxxxx
20931                                                                     fcvtpu.  */
20932                                                                  return 529;
20933                                                                }
20934                                                            }
20935                                                        }
20936                                                      else
20937                                                        {
20938                                                          if (((word >> 23) & 0x1) == 0)
20939                                                            {
20940                                                              if (((word >> 29) & 0x1) == 0)
20941                                                                {
20942                                                                  /* 33222222222211111111110000000000
20943                                                                     10987654321098765432109876543210
20944                                                                     xx0111100x1x1xx1101010xxxxxxxxxx
20945                                                                     fcvtns.  */
20946                                                                  return 488;
20947                                                                }
20948                                                              else
20949                                                                {
20950                                                                  /* 33222222222211111111110000000000
20951                                                                     10987654321098765432109876543210
20952                                                                     xx1111100x1x1xx1101010xxxxxxxxxx
20953                                                                     fcvtnu.  */
20954                                                                  return 518;
20955                                                                }
20956                                                            }
20957                                                          else
20958                                                            {
20959                                                              if (((word >> 29) & 0x1) == 0)
20960                                                                {
20961                                                                  /* 33222222222211111111110000000000
20962                                                                     10987654321098765432109876543210
20963                                                                     xx0111101x1x1xx1101010xxxxxxxxxx
20964                                                                     fcvtps.  */
20965                                                                  return 502;
20966                                                                }
20967                                                              else
20968                                                                {
20969                                                                  /* 33222222222211111111110000000000
20970                                                                     10987654321098765432109876543210
20971                                                                     xx1111101x1x1xx1101010xxxxxxxxxx
20972                                                                     fcvtpu.  */
20973                                                                  return 530;
20974                                                                }
20975                                                            }
20976                                                        }
20977                                                    }
20978                                                }
20979                                            }
20980                                          else
20981                                            {
20982                                              if (((word >> 15) & 0x1) == 0)
20983                                                {
20984                                                  if (((word >> 29) & 0x1) == 0)
20985                                                    {
20986                                                      /* 33222222222211111111110000000000
20987                                                         10987654321098765432109876543210
20988                                                         xx011110xx1xxxxx011010xxxxxxxxxx
20989                                                         fmaxnm.  */
20990                                                      return 851;
20991                                                    }
20992                                                  else
20993                                                    {
20994                                                      /* 33222222222211111111110000000000
20995                                                         10987654321098765432109876543210
20996                                                         xx111110xx1xxxxx011010xxxxxxxxxx
20997                                                         fcvtxn.  */
20998                                                      return 516;
20999                                                    }
21000                                                }
21001                                              else
21002                                                {
21003                                                  if (((word >> 19) & 0x1) == 0)
21004                                                    {
21005                                                      /* 33222222222211111111110000000000
21006                                                         10987654321098765432109876543210
21007                                                         xxx11110xx1x0xxx111010xxxxxxxxxx
21008                                                         fcmlt.  */
21009                                                      return 499;
21010                                                    }
21011                                                  else
21012                                                    {
21013                                                      /* 33222222222211111111110000000000
21014                                                         10987654321098765432109876543210
21015                                                         xxx11110xx1x1xxx111010xxxxxxxxxx
21016                                                         fcmlt.  */
21017                                                      return 500;
21018                                                    }
21019                                                }
21020                                            }
21021                                        }
21022                                    }
21023                                  else
21024                                    {
21025                                      if (((word >> 13) & 0x1) == 0)
21026                                        {
21027                                          if (((word >> 14) & 0x1) == 0)
21028                                            {
21029                                              if (((word >> 15) & 0x1) == 0)
21030                                                {
21031                                                  if (((word >> 30) & 0x1) == 0)
21032                                                    {
21033                                                      /* 33222222222211111111110000000000
21034                                                         10987654321098765432109876543210
21035                                                         x0x11110xx1xxxxx000110xxxxxxxxxx
21036                                                         fdiv.  */
21037                                                      return 841;
21038                                                    }
21039                                                  else
21040                                                    {
21041                                                      /* 33222222222211111111110000000000
21042                                                         10987654321098765432109876543210
21043                                                         x1x11110xx1xxxxx000110xxxxxxxxxx
21044                                                         sha1su1.  */
21045                                                      return 676;
21046                                                    }
21047                                                }
21048                                              else
21049                                                {
21050                                                  if (((word >> 29) & 0x1) == 0)
21051                                                    {
21052                                                      /* 33222222222211111111110000000000
21053                                                         10987654321098765432109876543210
21054                                                         xx011110xx1xxxxx100110xxxxxxxxxx
21055                                                         cmeq.  */
21056                                                      return 483;
21057                                                    }
21058                                                  else
21059                                                    {
21060                                                      /* 33222222222211111111110000000000
21061                                                         10987654321098765432109876543210
21062                                                         xx111110xx1xxxxx100110xxxxxxxxxx
21063                                                         cmle.  */
21064                                                      return 512;
21065                                                    }
21066                                                }
21067                                            }
21068                                          else
21069                                            {
21070                                              if (((word >> 15) & 0x1) == 0)
21071                                                {
21072                                                  /* 33222222222211111111110000000000
21073                                                     10987654321098765432109876543210
21074                                                     xxx11110xx1xxxxx010110xxxxxxxxxx
21075                                                     fmin.  */
21076                                                  return 849;
21077                                                }
21078                                              else
21079                                                {
21080                                                  if (((word >> 16) & 0x1) == 0)
21081                                                    {
21082                                                      if (((word >> 19) & 0x1) == 0)
21083                                                        {
21084                                                          if (((word >> 20) & 0x1) == 0)
21085                                                            {
21086                                                              if (((word >> 29) & 0x1) == 0)
21087                                                                {
21088                                                                  /* 33222222222211111111110000000000
21089                                                                     10987654321098765432109876543210
21090                                                                     xx011110xx100xx0110110xxxxxxxxxx
21091                                                                     fcmeq.  */
21092                                                                  return 497;
21093                                                                }
21094                                                              else
21095                                                                {
21096                                                                  /* 33222222222211111111110000000000
21097                                                                     10987654321098765432109876543210
21098                                                                     xx111110xx100xx0110110xxxxxxxxxx
21099                                                                     fcmle.  */
21100                                                                  return 527;
21101                                                                }
21102                                                            }
21103                                                          else
21104                                                            {
21105                                                              if (((word >> 29) & 0x1) == 0)
21106                                                                {
21107                                                                  /* 33222222222211111111110000000000
21108                                                                     10987654321098765432109876543210
21109                                                                     xx011110xx110xx0110110xxxxxxxxxx
21110                                                                     faddp.  */
21111                                                                  return 541;
21112                                                                }
21113                                                              else
21114                                                                {
21115                                                                  /* 33222222222211111111110000000000
21116                                                                     10987654321098765432109876543210
21117                                                                     xx111110xx110xx0110110xxxxxxxxxx
21118                                                                     faddp.  */
21119                                                                  return 540;
21120                                                                }
21121                                                            }
21122                                                        }
21123                                                      else
21124                                                        {
21125                                                          if (((word >> 29) & 0x1) == 0)
21126                                                            {
21127                                                              /* 33222222222211111111110000000000
21128                                                                 10987654321098765432109876543210
21129                                                                 xx011110xx1x1xx0110110xxxxxxxxxx
21130                                                                 fcmeq.  */
21131                                                              return 498;
21132                                                            }
21133                                                          else
21134                                                            {
21135                                                              /* 33222222222211111111110000000000
21136                                                                 10987654321098765432109876543210
21137                                                                 xx111110xx1x1xx0110110xxxxxxxxxx
21138                                                                 fcmle.  */
21139                                                              return 528;
21140                                                            }
21141                                                        }
21142                                                    }
21143                                                  else
21144                                                    {
21145                                                      if (((word >> 19) & 0x1) == 0)
21146                                                        {
21147                                                          if (((word >> 23) & 0x1) == 0)
21148                                                            {
21149                                                              if (((word >> 29) & 0x1) == 0)
21150                                                                {
21151                                                                  /* 33222222222211111111110000000000
21152                                                                     10987654321098765432109876543210
21153                                                                     xx0111100x1x0xx1110110xxxxxxxxxx
21154                                                                     scvtf.  */
21155                                                                  return 493;
21156                                                                }
21157                                                              else
21158                                                                {
21159                                                                  /* 33222222222211111111110000000000
21160                                                                     10987654321098765432109876543210
21161                                                                     xx1111100x1x0xx1110110xxxxxxxxxx
21162                                                                     ucvtf.  */
21163                                                                  return 523;
21164                                                                }
21165                                                            }
21166                                                          else
21167                                                            {
21168                                                              if (((word >> 29) & 0x1) == 0)
21169                                                                {
21170                                                                  /* 33222222222211111111110000000000
21171                                                                     10987654321098765432109876543210
21172                                                                     xx0111101x1x0xx1110110xxxxxxxxxx
21173                                                                     frecpe.  */
21174                                                                  return 505;
21175                                                                }
21176                                                              else
21177                                                                {
21178                                                                  /* 33222222222211111111110000000000
21179                                                                     10987654321098765432109876543210
21180                                                                     xx1111101x1x0xx1110110xxxxxxxxxx
21181                                                                     frsqrte.  */
21182                                                                  return 533;
21183                                                                }
21184                                                            }
21185                                                        }
21186                                                      else
21187                                                        {
21188                                                          if (((word >> 23) & 0x1) == 0)
21189                                                            {
21190                                                              if (((word >> 29) & 0x1) == 0)
21191                                                                {
21192                                                                  /* 33222222222211111111110000000000
21193                                                                     10987654321098765432109876543210
21194                                                                     xx0111100x1x1xx1110110xxxxxxxxxx
21195                                                                     scvtf.  */
21196                                                                  return 494;
21197                                                                }
21198                                                              else
21199                                                                {
21200                                                                  /* 33222222222211111111110000000000
21201                                                                     10987654321098765432109876543210
21202                                                                     xx1111100x1x1xx1110110xxxxxxxxxx
21203                                                                     ucvtf.  */
21204                                                                  return 524;
21205                                                                }
21206                                                            }
21207                                                          else
21208                                                            {
21209                                                              if (((word >> 29) & 0x1) == 0)
21210                                                                {
21211                                                                  /* 33222222222211111111110000000000
21212                                                                     10987654321098765432109876543210
21213                                                                     xx0111101x1x1xx1110110xxxxxxxxxx
21214                                                                     frecpe.  */
21215                                                                  return 506;
21216                                                                }
21217                                                              else
21218                                                                {
21219                                                                  /* 33222222222211111111110000000000
21220                                                                     10987654321098765432109876543210
21221                                                                     xx1111101x1x1xx1110110xxxxxxxxxx
21222                                                                     frsqrte.  */
21223                                                                  return 534;
21224                                                                }
21225                                                            }
21226                                                        }
21227                                                    }
21228                                                }
21229                                            }
21230                                        }
21231                                      else
21232                                        {
21233                                          if (((word >> 14) & 0x1) == 0)
21234                                            {
21235                                              if (((word >> 15) & 0x1) == 0)
21236                                                {
21237                                                  if (((word >> 29) & 0x1) == 0)
21238                                                    {
21239                                                      if (((word >> 30) & 0x1) == 0)
21240                                                        {
21241                                                          /* 33222222222211111111110000000000
21242                                                             10987654321098765432109876543210
21243                                                             x0011110xx1xxxxx001110xxxxxxxxxx
21244                                                             fsub.  */
21245                                                          return 845;
21246                                                        }
21247                                                      else
21248                                                        {
21249                                                          /* 33222222222211111111110000000000
21250                                                             10987654321098765432109876543210
21251                                                             x1011110xx1xxxxx001110xxxxxxxxxx
21252                                                             suqadd.  */
21253                                                          return 480;
21254                                                        }
21255                                                    }
21256                                                  else
21257                                                    {
21258                                                      /* 33222222222211111111110000000000
21259                                                         10987654321098765432109876543210
21260                                                         xx111110xx1xxxxx001110xxxxxxxxxx
21261                                                         usqadd.  */
21262                                                      return 509;
21263                                                    }
21264                                                }
21265                                              else
21266                                                {
21267                                                  if (((word >> 16) & 0x1) == 0)
21268                                                    {
21269                                                      if (((word >> 29) & 0x1) == 0)
21270                                                        {
21271                                                          /* 33222222222211111111110000000000
21272                                                             10987654321098765432109876543210
21273                                                             xx011110xx1xxxx0101110xxxxxxxxxx
21274                                                             abs.  */
21275                                                          return 485;
21276                                                        }
21277                                                      else
21278                                                        {
21279                                                          /* 33222222222211111111110000000000
21280                                                             10987654321098765432109876543210
21281                                                             xx111110xx1xxxx0101110xxxxxxxxxx
21282                                                             neg.  */
21283                                                          return 513;
21284                                                        }
21285                                                    }
21286                                                  else
21287                                                    {
21288                                                      if (((word >> 19) & 0x1) == 0)
21289                                                        {
21290                                                          if (((word >> 20) & 0x1) == 0)
21291                                                            {
21292                                                              if (((word >> 23) & 0x1) == 0)
21293                                                                {
21294                                                                  if (((word >> 29) & 0x1) == 0)
21295                                                                    {
21296                                                                      /* 33222222222211111111110000000000
21297                                                                         10987654321098765432109876543210
21298                                                                         xx0111100x100xx1101110xxxxxxxxxx
21299                                                                         fcvtms.  */
21300                                                                      return 489;
21301                                                                    }
21302                                                                  else
21303                                                                    {
21304                                                                      /* 33222222222211111111110000000000
21305                                                                         10987654321098765432109876543210
21306                                                                         xx1111100x100xx1101110xxxxxxxxxx
21307                                                                         fcvtmu.  */
21308                                                                      return 519;
21309                                                                    }
21310                                                                }
21311                                                              else
21312                                                                {
21313                                                                  if (((word >> 29) & 0x1) == 0)
21314                                                                    {
21315                                                                      /* 33222222222211111111110000000000
21316                                                                         10987654321098765432109876543210
21317                                                                         xx0111101x100xx1101110xxxxxxxxxx
21318                                                                         fcvtzs.  */
21319                                                                      return 503;
21320                                                                    }
21321                                                                  else
21322                                                                    {
21323                                                                      /* 33222222222211111111110000000000
21324                                                                         10987654321098765432109876543210
21325                                                                         xx1111101x100xx1101110xxxxxxxxxx
21326                                                                         fcvtzu.  */
21327                                                                      return 531;
21328                                                                    }
21329                                                                }
21330                                                            }
21331                                                          else
21332                                                            {
21333                                                              /* 33222222222211111111110000000000
21334                                                                 10987654321098765432109876543210
21335                                                                 xxx11110xx110xx1101110xxxxxxxxxx
21336                                                                 addp.  */
21337                                                              return 537;
21338                                                            }
21339                                                        }
21340                                                      else
21341                                                        {
21342                                                          if (((word >> 23) & 0x1) == 0)
21343                                                            {
21344                                                              if (((word >> 29) & 0x1) == 0)
21345                                                                {
21346                                                                  /* 33222222222211111111110000000000
21347                                                                     10987654321098765432109876543210
21348                                                                     xx0111100x1x1xx1101110xxxxxxxxxx
21349                                                                     fcvtms.  */
21350                                                                  return 490;
21351                                                                }
21352                                                              else
21353                                                                {
21354                                                                  /* 33222222222211111111110000000000
21355                                                                     10987654321098765432109876543210
21356                                                                     xx1111100x1x1xx1101110xxxxxxxxxx
21357                                                                     fcvtmu.  */
21358                                                                  return 520;
21359                                                                }
21360                                                            }
21361                                                          else
21362                                                            {
21363                                                              if (((word >> 29) & 0x1) == 0)
21364                                                                {
21365                                                                  /* 33222222222211111111110000000000
21366                                                                     10987654321098765432109876543210
21367                                                                     xx0111101x1x1xx1101110xxxxxxxxxx
21368                                                                     fcvtzs.  */
21369                                                                  return 504;
21370                                                                }
21371                                                              else
21372                                                                {
21373                                                                  /* 33222222222211111111110000000000
21374                                                                     10987654321098765432109876543210
21375                                                                     xx1111101x1x1xx1101110xxxxxxxxxx
21376                                                                     fcvtzu.  */
21377                                                                  return 532;
21378                                                                }
21379                                                            }
21380                                                        }
21381                                                    }
21382                                                }
21383                                            }
21384                                          else
21385                                            {
21386                                              if (((word >> 15) & 0x1) == 0)
21387                                                {
21388                                                  if (((word >> 29) & 0x1) == 0)
21389                                                    {
21390                                                      if (((word >> 30) & 0x1) == 0)
21391                                                        {
21392                                                          /* 33222222222211111111110000000000
21393                                                             10987654321098765432109876543210
21394                                                             x0011110xx1xxxxx011110xxxxxxxxxx
21395                                                             fminnm.  */
21396                                                          return 853;
21397                                                        }
21398                                                      else
21399                                                        {
21400                                                          /* 33222222222211111111110000000000
21401                                                             10987654321098765432109876543210
21402                                                             x1011110xx1xxxxx011110xxxxxxxxxx
21403                                                             sqabs.  */
21404                                                          return 481;
21405                                                        }
21406                                                    }
21407                                                  else
21408                                                    {
21409                                                      /* 33222222222211111111110000000000
21410                                                         10987654321098765432109876543210
21411                                                         xx111110xx1xxxxx011110xxxxxxxxxx
21412                                                         sqneg.  */
21413                                                      return 510;
21414                                                    }
21415                                                }
21416                                              else
21417                                                {
21418                                                  if (((word >> 16) & 0x1) == 0)
21419                                                    {
21420                                                      if (((word >> 23) & 0x1) == 0)
21421                                                        {
21422                                                          if (((word >> 29) & 0x1) == 0)
21423                                                            {
21424                                                              /* 33222222222211111111110000000000
21425                                                                 10987654321098765432109876543210
21426                                                                 xx0111100x1xxxx0111110xxxxxxxxxx
21427                                                                 fmaxp.  */
21428                                                              return 543;
21429                                                            }
21430                                                          else
21431                                                            {
21432                                                              /* 33222222222211111111110000000000
21433                                                                 10987654321098765432109876543210
21434                                                                 xx1111100x1xxxx0111110xxxxxxxxxx
21435                                                                 fmaxp.  */
21436                                                              return 542;
21437                                                            }
21438                                                        }
21439                                                      else
21440                                                        {
21441                                                          if (((word >> 29) & 0x1) == 0)
21442                                                            {
21443                                                              /* 33222222222211111111110000000000
21444                                                                 10987654321098765432109876543210
21445                                                                 xx0111101x1xxxx0111110xxxxxxxxxx
21446                                                                 fminp.  */
21447                                                              return 547;
21448                                                            }
21449                                                          else
21450                                                            {
21451                                                              /* 33222222222211111111110000000000
21452                                                                 10987654321098765432109876543210
21453                                                                 xx1111101x1xxxx0111110xxxxxxxxxx
21454                                                                 fminp.  */
21455                                                              return 546;
21456                                                            }
21457                                                        }
21458                                                    }
21459                                                  else
21460                                                    {
21461                                                      if (((word >> 19) & 0x1) == 0)
21462                                                        {
21463                                                          /* 33222222222211111111110000000000
21464                                                             10987654321098765432109876543210
21465                                                             xxx11110xx1x0xx1111110xxxxxxxxxx
21466                                                             frecpx.  */
21467                                                          return 507;
21468                                                        }
21469                                                      else
21470                                                        {
21471                                                          /* 33222222222211111111110000000000
21472                                                             10987654321098765432109876543210
21473                                                             xxx11110xx1x1xx1111110xxxxxxxxxx
21474                                                             frecpx.  */
21475                                                          return 508;
21476                                                        }
21477                                                    }
21478                                                }
21479                                            }
21480                                        }
21481                                    }
21482                                }
21483                            }
21484                          else
21485                            {
21486                              if (((word >> 11) & 0x1) == 0)
21487                                {
21488                                  if (((word >> 29) & 0x1) == 0)
21489                                    {
21490                                      if (((word >> 30) & 0x1) == 0)
21491                                        {
21492                                          if (((word >> 4) & 0x1) == 0)
21493                                            {
21494                                              /* 33222222222211111111110000000000
21495                                                 10987654321098765432109876543210
21496                                                 x0011110xx1xxxxxxxxx01xxxxx0xxxx
21497                                                 fccmp.  */
21498                                              return 798;
21499                                            }
21500                                          else
21501                                            {
21502                                              /* 33222222222211111111110000000000
21503                                                 10987654321098765432109876543210
21504                                                 x0011110xx1xxxxxxxxx01xxxxx1xxxx
21505                                                 fccmpe.  */
21506                                              return 800;
21507                                            }
21508                                        }
21509                                      else
21510                                        {
21511                                          if (((word >> 12) & 0x1) == 0)
21512                                            {
21513                                              if (((word >> 13) & 0x1) == 0)
21514                                                {
21515                                                  if (((word >> 14) & 0x1) == 0)
21516                                                    {
21517                                                      /* 33222222222211111111110000000000
21518                                                         10987654321098765432109876543210
21519                                                         x1011110xx1xxxxxx00001xxxxxxxxxx
21520                                                         add.  */
21521                                                      return 565;
21522                                                    }
21523                                                  else
21524                                                    {
21525                                                      /* 33222222222211111111110000000000
21526                                                         10987654321098765432109876543210
21527                                                         x1011110xx1xxxxxx10001xxxxxxxxxx
21528                                                         sshl.  */
21529                                                      return 563;
21530                                                    }
21531                                                }
21532                                              else
21533                                                {
21534                                                  /* 33222222222211111111110000000000
21535                                                     10987654321098765432109876543210
21536                                                     x1011110xx1xxxxxxx1001xxxxxxxxxx
21537                                                     fcmeq.  */
21538                                                  return 555;
21539                                                }
21540                                            }
21541                                          else
21542                                            {
21543                                              if (((word >> 13) & 0x1) == 0)
21544                                                {
21545                                                  /* 33222222222211111111110000000000
21546                                                     10987654321098765432109876543210
21547                                                     x1011110xx1xxxxxxx0101xxxxxxxxxx
21548                                                     srshl.  */
21549                                                  return 564;
21550                                                }
21551                                              else
21552                                                {
21553                                                  if (((word >> 15) & 0x1) == 0)
21554                                                    {
21555                                                      /* 33222222222211111111110000000000
21556                                                         10987654321098765432109876543210
21557                                                         x1011110xx1xxxxx0x1101xxxxxxxxxx
21558                                                         cmgt.  */
21559                                                      return 561;
21560                                                    }
21561                                                  else
21562                                                    {
21563                                                      /* 33222222222211111111110000000000
21564                                                         10987654321098765432109876543210
21565                                                         x1011110xx1xxxxx1x1101xxxxxxxxxx
21566                                                         sqdmulh.  */
21567                                                      return 552;
21568                                                    }
21569                                                }
21570                                            }
21571                                        }
21572                                    }
21573                                  else
21574                                    {
21575                                      if (((word >> 12) & 0x1) == 0)
21576                                        {
21577                                          if (((word >> 13) & 0x1) == 0)
21578                                            {
21579                                              if (((word >> 14) & 0x1) == 0)
21580                                                {
21581                                                  /* 33222222222211111111110000000000
21582                                                     10987654321098765432109876543210
21583                                                     xx111110xx1xxxxxx00001xxxxxxxxxx
21584                                                     sub.  */
21585                                                  return 586;
21586                                                }
21587                                              else
21588                                                {
21589                                                  /* 33222222222211111111110000000000
21590                                                     10987654321098765432109876543210
21591                                                     xx111110xx1xxxxxx10001xxxxxxxxxx
21592                                                     ushl.  */
21593                                                  return 584;
21594                                                }
21595                                            }
21596                                          else
21597                                            {
21598                                              if (((word >> 23) & 0x1) == 0)
21599                                                {
21600                                                  /* 33222222222211111111110000000000
21601                                                     10987654321098765432109876543210
21602                                                     xx1111100x1xxxxxxx1001xxxxxxxxxx
21603                                                     fcmge.  */
21604                                                  return 572;
21605                                                }
21606                                              else
21607                                                {
21608                                                  /* 33222222222211111111110000000000
21609                                                     10987654321098765432109876543210
21610                                                     xx1111101x1xxxxxxx1001xxxxxxxxxx
21611                                                     fcmgt.  */
21612                                                  return 578;
21613                                                }
21614                                            }
21615                                        }
21616                                      else
21617                                        {
21618                                          if (((word >> 13) & 0x1) == 0)
21619                                            {
21620                                              if (((word >> 15) & 0x1) == 0)
21621                                                {
21622                                                  /* 33222222222211111111110000000000
21623                                                     10987654321098765432109876543210
21624                                                     xx111110xx1xxxxx0x0101xxxxxxxxxx
21625                                                     urshl.  */
21626                                                  return 585;
21627                                                }
21628                                              else
21629                                                {
21630                                                  /* 33222222222211111111110000000000
21631                                                     10987654321098765432109876543210
21632                                                     xx111110xx1xxxxx1x0101xxxxxxxxxx
21633                                                     fabd.  */
21634                                                  return 576;
21635                                                }
21636                                            }
21637                                          else
21638                                            {
21639                                              if (((word >> 15) & 0x1) == 0)
21640                                                {
21641                                                  /* 33222222222211111111110000000000
21642                                                     10987654321098765432109876543210
21643                                                     xx111110xx1xxxxx0x1101xxxxxxxxxx
21644                                                     cmhi.  */
21645                                                  return 582;
21646                                                }
21647                                              else
21648                                                {
21649                                                  /* 33222222222211111111110000000000
21650                                                     10987654321098765432109876543210
21651                                                     xx111110xx1xxxxx1x1101xxxxxxxxxx
21652                                                     sqrdmulh.  */
21653                                                  return 571;
21654                                                }
21655                                            }
21656                                        }
21657                                    }
21658                                }
21659                              else
21660                                {
21661                                  if (((word >> 29) & 0x1) == 0)
21662                                    {
21663                                      if (((word >> 30) & 0x1) == 0)
21664                                        {
21665                                          /* 33222222222211111111110000000000
21666                                             10987654321098765432109876543210
21667                                             x0011110xx1xxxxxxxxx11xxxxxxxxxx
21668                                             fcsel.  */
21669                                          return 867;
21670                                        }
21671                                      else
21672                                        {
21673                                          if (((word >> 12) & 0x1) == 0)
21674                                            {
21675                                              if (((word >> 13) & 0x1) == 0)
21676                                                {
21677                                                  if (((word >> 14) & 0x1) == 0)
21678                                                    {
21679                                                      if (((word >> 15) & 0x1) == 0)
21680                                                        {
21681                                                          /* 33222222222211111111110000000000
21682                                                             10987654321098765432109876543210
21683                                                             x1011110xx1xxxxx000011xxxxxxxxxx
21684                                                             sqadd.  */
21685                                                          return 548;
21686                                                        }
21687                                                      else
21688                                                        {
21689                                                          /* 33222222222211111111110000000000
21690                                                             10987654321098765432109876543210
21691                                                             x1011110xx1xxxxx100011xxxxxxxxxx
21692                                                             cmtst.  */
21693                                                          return 566;
21694                                                        }
21695                                                    }
21696                                                  else
21697                                                    {
21698                                                      /* 33222222222211111111110000000000
21699                                                         10987654321098765432109876543210
21700                                                         x1011110xx1xxxxxx10011xxxxxxxxxx
21701                                                         sqshl.  */
21702                                                      return 550;
21703                                                    }
21704                                                }
21705                                              else
21706                                                {
21707                                                  /* 33222222222211111111110000000000
21708                                                     10987654321098765432109876543210
21709                                                     x1011110xx1xxxxxxx1011xxxxxxxxxx
21710                                                     sqsub.  */
21711                                                  return 549;
21712                                                }
21713                                            }
21714                                          else
21715                                            {
21716                                              if (((word >> 13) & 0x1) == 0)
21717                                                {
21718                                                  if (((word >> 15) & 0x1) == 0)
21719                                                    {
21720                                                      /* 33222222222211111111110000000000
21721                                                         10987654321098765432109876543210
21722                                                         x1011110xx1xxxxx0x0111xxxxxxxxxx
21723                                                         sqrshl.  */
21724                                                      return 551;
21725                                                    }
21726                                                  else
21727                                                    {
21728                                                      /* 33222222222211111111110000000000
21729                                                         10987654321098765432109876543210
21730                                                         x1011110xx1xxxxx1x0111xxxxxxxxxx
21731                                                         fmulx.  */
21732                                                      return 553;
21733                                                    }
21734                                                }
21735                                              else
21736                                                {
21737                                                  if (((word >> 14) & 0x1) == 0)
21738                                                    {
21739                                                      /* 33222222222211111111110000000000
21740                                                         10987654321098765432109876543210
21741                                                         x1011110xx1xxxxxx01111xxxxxxxxxx
21742                                                         cmge.  */
21743                                                      return 562;
21744                                                    }
21745                                                  else
21746                                                    {
21747                                                      if (((word >> 23) & 0x1) == 0)
21748                                                        {
21749                                                          /* 33222222222211111111110000000000
21750                                                             10987654321098765432109876543210
21751                                                             x10111100x1xxxxxx11111xxxxxxxxxx
21752                                                             frecps.  */
21753                                                          return 557;
21754                                                        }
21755                                                      else
21756                                                        {
21757                                                          /* 33222222222211111111110000000000
21758                                                             10987654321098765432109876543210
21759                                                             x10111101x1xxxxxx11111xxxxxxxxxx
21760                                                             frsqrts.  */
21761                                                          return 559;
21762                                                        }
21763                                                    }
21764                                                }
21765                                            }
21766                                        }
21767                                    }
21768                                  else
21769                                    {
21770                                      if (((word >> 12) & 0x1) == 0)
21771                                        {
21772                                          if (((word >> 13) & 0x1) == 0)
21773                                            {
21774                                              if (((word >> 14) & 0x1) == 0)
21775                                                {
21776                                                  if (((word >> 15) & 0x1) == 0)
21777                                                    {
21778                                                      /* 33222222222211111111110000000000
21779                                                         10987654321098765432109876543210
21780                                                         xx111110xx1xxxxx000011xxxxxxxxxx
21781                                                         uqadd.  */
21782                                                      return 567;
21783                                                    }
21784                                                  else
21785                                                    {
21786                                                      /* 33222222222211111111110000000000
21787                                                         10987654321098765432109876543210
21788                                                         xx111110xx1xxxxx100011xxxxxxxxxx
21789                                                         cmeq.  */
21790                                                      return 587;
21791                                                    }
21792                                                }
21793                                              else
21794                                                {
21795                                                  /* 33222222222211111111110000000000
21796                                                     10987654321098765432109876543210
21797                                                     xx111110xx1xxxxxx10011xxxxxxxxxx
21798                                                     uqshl.  */
21799                                                  return 569;
21800                                                }
21801                                            }
21802                                          else
21803                                            {
21804                                              if (((word >> 14) & 0x1) == 0)
21805                                                {
21806                                                  /* 33222222222211111111110000000000
21807                                                     10987654321098765432109876543210
21808                                                     xx111110xx1xxxxxx01011xxxxxxxxxx
21809                                                     uqsub.  */
21810                                                  return 568;
21811                                                }
21812                                              else
21813                                                {
21814                                                  if (((word >> 23) & 0x1) == 0)
21815                                                    {
21816                                                      /* 33222222222211111111110000000000
21817                                                         10987654321098765432109876543210
21818                                                         xx1111100x1xxxxxx11011xxxxxxxxxx
21819                                                         facge.  */
21820                                                      return 574;
21821                                                    }
21822                                                  else
21823                                                    {
21824                                                      /* 33222222222211111111110000000000
21825                                                         10987654321098765432109876543210
21826                                                         xx1111101x1xxxxxx11011xxxxxxxxxx
21827                                                         facgt.  */
21828                                                      return 580;
21829                                                    }
21830                                                }
21831                                            }
21832                                        }
21833                                      else
21834                                        {
21835                                          if (((word >> 13) & 0x1) == 0)
21836                                            {
21837                                              /* 33222222222211111111110000000000
21838                                                 10987654321098765432109876543210
21839                                                 xx111110xx1xxxxxxx0111xxxxxxxxxx
21840                                                 uqrshl.  */
21841                                              return 570;
21842                                            }
21843                                          else
21844                                            {
21845                                              /* 33222222222211111111110000000000
21846                                                 10987654321098765432109876543210
21847                                                 xx111110xx1xxxxxxx1111xxxxxxxxxx
21848                                                 cmhs.  */
21849                                              return 583;
21850                                            }
21851                                        }
21852                                    }
21853                                }
21854                            }
21855                        }
21856                    }
21857                }
21858              else
21859                {
21860                  if (((word >> 15) & 0x1) == 0)
21861                    {
21862                      if (((word >> 28) & 0x1) == 0)
21863                        {
21864                          if (((word >> 10) & 0x1) == 0)
21865                            {
21866                              if (((word >> 12) & 0x1) == 0)
21867                                {
21868                                  if (((word >> 13) & 0x1) == 0)
21869                                    {
21870                                      if (((word >> 14) & 0x1) == 0)
21871                                        {
21872                                          if (((word >> 29) & 0x1) == 0)
21873                                            {
21874                                              if (((word >> 30) & 0x1) == 0)
21875                                                {
21876                                                  /* 33222222222211111111110000000000
21877                                                     10987654321098765432109876543210
21878                                                     x0001111xxxxxxxx0000x0xxxxxxxxxx
21879                                                     fmlal.  */
21880                                                  return 2366;
21881                                                }
21882                                              else
21883                                                {
21884                                                  /* 33222222222211111111110000000000
21885                                                     10987654321098765432109876543210
21886                                                     x1001111xxxxxxxx0000x0xxxxxxxxxx
21887                                                     fmlal.  */
21888                                                  return 2370;
21889                                                }
21890                                            }
21891                                          else
21892                                            {
21893                                              /* 33222222222211111111110000000000
21894                                                 10987654321098765432109876543210
21895                                                 xx101111xxxxxxxx0000x0xxxxxxxxxx
21896                                                 mla.  */
21897                                              return 119;
21898                                            }
21899                                        }
21900                                      else
21901                                        {
21902                                          if (((word >> 29) & 0x1) == 0)
21903                                            {
21904                                              if (((word >> 30) & 0x1) == 0)
21905                                                {
21906                                                  /* 33222222222211111111110000000000
21907                                                     10987654321098765432109876543210
21908                                                     x0001111xxxxxxxx0100x0xxxxxxxxxx
21909                                                     fmlsl.  */
21910                                                  return 2367;
21911                                                }
21912                                              else
21913                                                {
21914                                                  /* 33222222222211111111110000000000
21915                                                     10987654321098765432109876543210
21916                                                     x1001111xxxxxxxx0100x0xxxxxxxxxx
21917                                                     fmlsl.  */
21918                                                  return 2371;
21919                                                }
21920                                            }
21921                                          else
21922                                            {
21923                                              /* 33222222222211111111110000000000
21924                                                 10987654321098765432109876543210
21925                                                 xx101111xxxxxxxx0100x0xxxxxxxxxx
21926                                                 mls.  */
21927                                              return 122;
21928                                            }
21929                                        }
21930                                    }
21931                                  else
21932                                    {
21933                                      if (((word >> 14) & 0x1) == 0)
21934                                        {
21935                                          if (((word >> 29) & 0x1) == 0)
21936                                            {
21937                                              if (((word >> 30) & 0x1) == 0)
21938                                                {
21939                                                  /* 33222222222211111111110000000000
21940                                                     10987654321098765432109876543210
21941                                                     x0001111xxxxxxxx0010x0xxxxxxxxxx
21942                                                     smlal.  */
21943                                                  return 98;
21944                                                }
21945                                              else
21946                                                {
21947                                                  /* 33222222222211111111110000000000
21948                                                     10987654321098765432109876543210
21949                                                     x1001111xxxxxxxx0010x0xxxxxxxxxx
21950                                                     smlal2.  */
21951                                                  return 99;
21952                                                }
21953                                            }
21954                                          else
21955                                            {
21956                                              if (((word >> 30) & 0x1) == 0)
21957                                                {
21958                                                  /* 33222222222211111111110000000000
21959                                                     10987654321098765432109876543210
21960                                                     x0101111xxxxxxxx0010x0xxxxxxxxxx
21961                                                     umlal.  */
21962                                                  return 120;
21963                                                }
21964                                              else
21965                                                {
21966                                                  /* 33222222222211111111110000000000
21967                                                     10987654321098765432109876543210
21968                                                     x1101111xxxxxxxx0010x0xxxxxxxxxx
21969                                                     umlal2.  */
21970                                                  return 121;
21971                                                }
21972                                            }
21973                                        }
21974                                      else
21975                                        {
21976                                          if (((word >> 29) & 0x1) == 0)
21977                                            {
21978                                              if (((word >> 30) & 0x1) == 0)
21979                                                {
21980                                                  /* 33222222222211111111110000000000
21981                                                     10987654321098765432109876543210
21982                                                     x0001111xxxxxxxx0110x0xxxxxxxxxx
21983                                                     smlsl.  */
21984                                                  return 102;
21985                                                }
21986                                              else
21987                                                {
21988                                                  /* 33222222222211111111110000000000
21989                                                     10987654321098765432109876543210
21990                                                     x1001111xxxxxxxx0110x0xxxxxxxxxx
21991                                                     smlsl2.  */
21992                                                  return 103;
21993                                                }
21994                                            }
21995                                          else
21996                                            {
21997                                              if (((word >> 30) & 0x1) == 0)
21998                                                {
21999                                                  /* 33222222222211111111110000000000
22000                                                     10987654321098765432109876543210
22001                                                     x0101111xxxxxxxx0110x0xxxxxxxxxx
22002                                                     umlsl.  */
22003                                                  return 123;
22004                                                }
22005                                              else
22006                                                {
22007                                                  /* 33222222222211111111110000000000
22008                                                     10987654321098765432109876543210
22009                                                     x1101111xxxxxxxx0110x0xxxxxxxxxx
22010                                                     umlsl2.  */
22011                                                  return 124;
22012                                                }
22013                                            }
22014                                        }
22015                                    }
22016                                }
22017                              else
22018                                {
22019                                  if (((word >> 29) & 0x1) == 0)
22020                                    {
22021                                      if (((word >> 13) & 0x1) == 0)
22022                                        {
22023                                          if (((word >> 14) & 0x1) == 0)
22024                                            {
22025                                              if (((word >> 23) & 0x1) == 0)
22026                                                {
22027                                                  /* 33222222222211111111110000000000
22028                                                     10987654321098765432109876543210
22029                                                     xx0011110xxxxxxx0001x0xxxxxxxxxx
22030                                                     fmla.  */
22031                                                  return 114;
22032                                                }
22033                                              else
22034                                                {
22035                                                  /* 33222222222211111111110000000000
22036                                                     10987654321098765432109876543210
22037                                                     xx0011111xxxxxxx0001x0xxxxxxxxxx
22038                                                     fmla.  */
22039                                                  return 113;
22040                                                }
22041                                            }
22042                                          else
22043                                            {
22044                                              if (((word >> 23) & 0x1) == 0)
22045                                                {
22046                                                  /* 33222222222211111111110000000000
22047                                                     10987654321098765432109876543210
22048                                                     xx0011110xxxxxxx0101x0xxxxxxxxxx
22049                                                     fmls.  */
22050                                                  return 116;
22051                                                }
22052                                              else
22053                                                {
22054                                                  /* 33222222222211111111110000000000
22055                                                     10987654321098765432109876543210
22056                                                     xx0011111xxxxxxx0101x0xxxxxxxxxx
22057                                                     fmls.  */
22058                                                  return 115;
22059                                                }
22060                                            }
22061                                        }
22062                                      else
22063                                        {
22064                                          if (((word >> 14) & 0x1) == 0)
22065                                            {
22066                                              if (((word >> 30) & 0x1) == 0)
22067                                                {
22068                                                  /* 33222222222211111111110000000000
22069                                                     10987654321098765432109876543210
22070                                                     x0001111xxxxxxxx0011x0xxxxxxxxxx
22071                                                     sqdmlal.  */
22072                                                  return 100;
22073                                                }
22074                                              else
22075                                                {
22076                                                  /* 33222222222211111111110000000000
22077                                                     10987654321098765432109876543210
22078                                                     x1001111xxxxxxxx0011x0xxxxxxxxxx
22079                                                     sqdmlal2.  */
22080                                                  return 101;
22081                                                }
22082                                            }
22083                                          else
22084                                            {
22085                                              if (((word >> 30) & 0x1) == 0)
22086                                                {
22087                                                  /* 33222222222211111111110000000000
22088                                                     10987654321098765432109876543210
22089                                                     x0001111xxxxxxxx0111x0xxxxxxxxxx
22090                                                     sqdmlsl.  */
22091                                                  return 104;
22092                                                }
22093                                              else
22094                                                {
22095                                                  /* 33222222222211111111110000000000
22096                                                     10987654321098765432109876543210
22097                                                     x1001111xxxxxxxx0111x0xxxxxxxxxx
22098                                                     sqdmlsl2.  */
22099                                                  return 105;
22100                                                }
22101                                            }
22102                                        }
22103                                    }
22104                                  else
22105                                    {
22106                                      /* 33222222222211111111110000000000
22107                                         10987654321098765432109876543210
22108                                         xx101111xxxxxxxx0xx1x0xxxxxxxxxx
22109                                         fcmla.  */
22110                                      return 131;
22111                                    }
22112                                }
22113                            }
22114                          else
22115                            {
22116                              if (((word >> 12) & 0x1) == 0)
22117                                {
22118                                  if (((word >> 29) & 0x1) == 0)
22119                                    {
22120                                      /* 33222222222211111111110000000000
22121                                         10987654321098765432109876543210
22122                                         xx001111xxxxxxxx0xx0x1xxxxxxxxxx
22123                                         movi.  */
22124                                      return 133;
22125                                    }
22126                                  else
22127                                    {
22128                                      /* 33222222222211111111110000000000
22129                                         10987654321098765432109876543210
22130                                         xx101111xxxxxxxx0xx0x1xxxxxxxxxx
22131                                         mvni.  */
22132                                      return 141;
22133                                    }
22134                                }
22135                              else
22136                                {
22137                                  if (((word >> 29) & 0x1) == 0)
22138                                    {
22139                                      /* 33222222222211111111110000000000
22140                                         10987654321098765432109876543210
22141                                         xx001111xxxxxxxx0xx1x1xxxxxxxxxx
22142                                         orr.  */
22143                                      return 134;
22144                                    }
22145                                  else
22146                                    {
22147                                      /* 33222222222211111111110000000000
22148                                         10987654321098765432109876543210
22149                                         xx101111xxxxxxxx0xx1x1xxxxxxxxxx
22150                                         bic.  */
22151                                      return 142;
22152                                    }
22153                                }
22154                            }
22155                        }
22156                      else
22157                        {
22158                          if (((word >> 29) & 0x1) == 0)
22159                            {
22160                              if (((word >> 30) & 0x1) == 0)
22161                                {
22162                                  if (((word >> 21) & 0x1) == 0)
22163                                    {
22164                                      /* 33222222222211111111110000000000
22165                                         10987654321098765432109876543210
22166                                         x0011111xx0xxxxx0xxxxxxxxxxxxxxx
22167                                         fmadd.  */
22168                                      return 857;
22169                                    }
22170                                  else
22171                                    {
22172                                      /* 33222222222211111111110000000000
22173                                         10987654321098765432109876543210
22174                                         x0011111xx1xxxxx0xxxxxxxxxxxxxxx
22175                                         fnmadd.  */
22176                                      return 861;
22177                                    }
22178                                }
22179                              else
22180                                {
22181                                  if (((word >> 10) & 0x1) == 0)
22182                                    {
22183                                      if (((word >> 13) & 0x1) == 0)
22184                                        {
22185                                          if (((word >> 14) & 0x1) == 0)
22186                                            {
22187                                              if (((word >> 23) & 0x1) == 0)
22188                                                {
22189                                                  /* 33222222222211111111110000000000
22190                                                     10987654321098765432109876543210
22191                                                     x10111110xxxxxxx000xx0xxxxxxxxxx
22192                                                     fmla.  */
22193                                                  return 431;
22194                                                }
22195                                              else
22196                                                {
22197                                                  /* 33222222222211111111110000000000
22198                                                     10987654321098765432109876543210
22199                                                     x10111111xxxxxxx000xx0xxxxxxxxxx
22200                                                     fmla.  */
22201                                                  return 430;
22202                                                }
22203                                            }
22204                                          else
22205                                            {
22206                                              if (((word >> 23) & 0x1) == 0)
22207                                                {
22208                                                  /* 33222222222211111111110000000000
22209                                                     10987654321098765432109876543210
22210                                                     x10111110xxxxxxx010xx0xxxxxxxxxx
22211                                                     fmls.  */
22212                                                  return 433;
22213                                                }
22214                                              else
22215                                                {
22216                                                  /* 33222222222211111111110000000000
22217                                                     10987654321098765432109876543210
22218                                                     x10111111xxxxxxx010xx0xxxxxxxxxx
22219                                                     fmls.  */
22220                                                  return 432;
22221                                                }
22222                                            }
22223                                        }
22224                                      else
22225                                        {
22226                                          if (((word >> 14) & 0x1) == 0)
22227                                            {
22228                                              /* 33222222222211111111110000000000
22229                                                 10987654321098765432109876543210
22230                                                 x1011111xxxxxxxx001xx0xxxxxxxxxx
22231                                                 sqdmlal.  */
22232                                              return 425;
22233                                            }
22234                                          else
22235                                            {
22236                                              /* 33222222222211111111110000000000
22237                                                 10987654321098765432109876543210
22238                                                 x1011111xxxxxxxx011xx0xxxxxxxxxx
22239                                                 sqdmlsl.  */
22240                                              return 426;
22241                                            }
22242                                        }
22243                                    }
22244                                  else
22245                                    {
22246                                      if (((word >> 12) & 0x1) == 0)
22247                                        {
22248                                          if (((word >> 13) & 0x1) == 0)
22249                                            {
22250                                              /* 33222222222211111111110000000000
22251                                                 10987654321098765432109876543210
22252                                                 x1011111xxxxxxxx0x00x1xxxxxxxxxx
22253                                                 sshr.  */
22254                                              return 590;
22255                                            }
22256                                          else
22257                                            {
22258                                              /* 33222222222211111111110000000000
22259                                                 10987654321098765432109876543210
22260                                                 x1011111xxxxxxxx0x10x1xxxxxxxxxx
22261                                                 srshr.  */
22262                                              return 592;
22263                                            }
22264                                        }
22265                                      else
22266                                        {
22267                                          if (((word >> 13) & 0x1) == 0)
22268                                            {
22269                                              if (((word >> 14) & 0x1) == 0)
22270                                                {
22271                                                  /* 33222222222211111111110000000000
22272                                                     10987654321098765432109876543210
22273                                                     x1011111xxxxxxxx0001x1xxxxxxxxxx
22274                                                     ssra.  */
22275                                                  return 591;
22276                                                }
22277                                              else
22278                                                {
22279                                                  /* 33222222222211111111110000000000
22280                                                     10987654321098765432109876543210
22281                                                     x1011111xxxxxxxx0101x1xxxxxxxxxx
22282                                                     shl.  */
22283                                                  return 594;
22284                                                }
22285                                            }
22286                                          else
22287                                            {
22288                                              if (((word >> 14) & 0x1) == 0)
22289                                                {
22290                                                  /* 33222222222211111111110000000000
22291                                                     10987654321098765432109876543210
22292                                                     x1011111xxxxxxxx0011x1xxxxxxxxxx
22293                                                     srsra.  */
22294                                                  return 593;
22295                                                }
22296                                              else
22297                                                {
22298                                                  /* 33222222222211111111110000000000
22299                                                     10987654321098765432109876543210
22300                                                     x1011111xxxxxxxx0111x1xxxxxxxxxx
22301                                                     sqshl.  */
22302                                                  return 595;
22303                                                }
22304                                            }
22305                                        }
22306                                    }
22307                                }
22308                            }
22309                          else
22310                            {
22311                              if (((word >> 12) & 0x1) == 0)
22312                                {
22313                                  if (((word >> 13) & 0x1) == 0)
22314                                    {
22315                                      if (((word >> 14) & 0x1) == 0)
22316                                        {
22317                                          /* 33222222222211111111110000000000
22318                                             10987654321098765432109876543210
22319                                             xx111111xxxxxxxx0000xxxxxxxxxxxx
22320                                             ushr.  */
22321                                          return 602;
22322                                        }
22323                                      else
22324                                        {
22325                                          /* 33222222222211111111110000000000
22326                                             10987654321098765432109876543210
22327                                             xx111111xxxxxxxx0100xxxxxxxxxxxx
22328                                             sri.  */
22329                                          return 606;
22330                                        }
22331                                    }
22332                                  else
22333                                    {
22334                                      if (((word >> 14) & 0x1) == 0)
22335                                        {
22336                                          /* 33222222222211111111110000000000
22337                                             10987654321098765432109876543210
22338                                             xx111111xxxxxxxx0010xxxxxxxxxxxx
22339                                             urshr.  */
22340                                          return 604;
22341                                        }
22342                                      else
22343                                        {
22344                                          /* 33222222222211111111110000000000
22345                                             10987654321098765432109876543210
22346                                             xx111111xxxxxxxx0110xxxxxxxxxxxx
22347                                             sqshlu.  */
22348                                          return 608;
22349                                        }
22350                                    }
22351                                }
22352                              else
22353                                {
22354                                  if (((word >> 13) & 0x1) == 0)
22355                                    {
22356                                      if (((word >> 14) & 0x1) == 0)
22357                                        {
22358                                          /* 33222222222211111111110000000000
22359                                             10987654321098765432109876543210
22360                                             xx111111xxxxxxxx0001xxxxxxxxxxxx
22361                                             usra.  */
22362                                          return 603;
22363                                        }
22364                                      else
22365                                        {
22366                                          /* 33222222222211111111110000000000
22367                                             10987654321098765432109876543210
22368                                             xx111111xxxxxxxx0101xxxxxxxxxxxx
22369                                             sli.  */
22370                                          return 607;
22371                                        }
22372                                    }
22373                                  else
22374                                    {
22375                                      if (((word >> 14) & 0x1) == 0)
22376                                        {
22377                                          /* 33222222222211111111110000000000
22378                                             10987654321098765432109876543210
22379                                             xx111111xxxxxxxx0011xxxxxxxxxxxx
22380                                             ursra.  */
22381                                          return 605;
22382                                        }
22383                                      else
22384                                        {
22385                                          /* 33222222222211111111110000000000
22386                                             10987654321098765432109876543210
22387                                             xx111111xxxxxxxx0111xxxxxxxxxxxx
22388                                             uqshl.  */
22389                                          return 609;
22390                                        }
22391                                    }
22392                                }
22393                            }
22394                        }
22395                    }
22396                  else
22397                    {
22398                      if (((word >> 28) & 0x1) == 0)
22399                        {
22400                          if (((word >> 10) & 0x1) == 0)
22401                            {
22402                              if (((word >> 12) & 0x1) == 0)
22403                                {
22404                                  if (((word >> 13) & 0x1) == 0)
22405                                    {
22406                                      if (((word >> 14) & 0x1) == 0)
22407                                        {
22408                                          if (((word >> 29) & 0x1) == 0)
22409                                            {
22410                                              /* 33222222222211111111110000000000
22411                                                 10987654321098765432109876543210
22412                                                 xx001111xxxxxxxx1000x0xxxxxxxxxx
22413                                                 mul.  */
22414                                              return 106;
22415                                            }
22416                                          else
22417                                            {
22418                                              if (((word >> 30) & 0x1) == 0)
22419                                                {
22420                                                  /* 33222222222211111111110000000000
22421                                                     10987654321098765432109876543210
22422                                                     x0101111xxxxxxxx1000x0xxxxxxxxxx
22423                                                     fmlal2.  */
22424                                                  return 2368;
22425                                                }
22426                                              else
22427                                                {
22428                                                  /* 33222222222211111111110000000000
22429                                                     10987654321098765432109876543210
22430                                                     x1101111xxxxxxxx1000x0xxxxxxxxxx
22431                                                     fmlal2.  */
22432                                                  return 2372;
22433                                                }
22434                                            }
22435                                        }
22436                                      else
22437                                        {
22438                                          if (((word >> 29) & 0x1) == 0)
22439                                            {
22440                                              /* 33222222222211111111110000000000
22441                                                 10987654321098765432109876543210
22442                                                 xx001111xxxxxxxx1100x0xxxxxxxxxx
22443                                                 sqdmulh.  */
22444                                              return 111;
22445                                            }
22446                                          else
22447                                            {
22448                                              if (((word >> 30) & 0x1) == 0)
22449                                                {
22450                                                  /* 33222222222211111111110000000000
22451                                                     10987654321098765432109876543210
22452                                                     x0101111xxxxxxxx1100x0xxxxxxxxxx
22453                                                     fmlsl2.  */
22454                                                  return 2369;
22455                                                }
22456                                              else
22457                                                {
22458                                                  /* 33222222222211111111110000000000
22459                                                     10987654321098765432109876543210
22460                                                     x1101111xxxxxxxx1100x0xxxxxxxxxx
22461                                                     fmlsl2.  */
22462                                                  return 2373;
22463                                                }
22464                                            }
22465                                        }
22466                                    }
22467                                  else
22468                                    {
22469                                      if (((word >> 14) & 0x1) == 0)
22470                                        {
22471                                          if (((word >> 29) & 0x1) == 0)
22472                                            {
22473                                              if (((word >> 30) & 0x1) == 0)
22474                                                {
22475                                                  /* 33222222222211111111110000000000
22476                                                     10987654321098765432109876543210
22477                                                     x0001111xxxxxxxx1010x0xxxxxxxxxx
22478                                                     smull.  */
22479                                                  return 107;
22480                                                }
22481                                              else
22482                                                {
22483                                                  /* 33222222222211111111110000000000
22484                                                     10987654321098765432109876543210
22485                                                     x1001111xxxxxxxx1010x0xxxxxxxxxx
22486                                                     smull2.  */
22487                                                  return 108;
22488                                                }
22489                                            }
22490                                          else
22491                                            {
22492                                              if (((word >> 30) & 0x1) == 0)
22493                                                {
22494                                                  /* 33222222222211111111110000000000
22495                                                     10987654321098765432109876543210
22496                                                     x0101111xxxxxxxx1010x0xxxxxxxxxx
22497                                                     umull.  */
22498                                                  return 125;
22499                                                }
22500                                              else
22501                                                {
22502                                                  /* 33222222222211111111110000000000
22503                                                     10987654321098765432109876543210
22504                                                     x1101111xxxxxxxx1010x0xxxxxxxxxx
22505                                                     umull2.  */
22506                                                  return 126;
22507                                                }
22508                                            }
22509                                        }
22510                                      else
22511                                        {
22512                                          if (((word >> 29) & 0x1) == 0)
22513                                            {
22514                                              /* 33222222222211111111110000000000
22515                                                 10987654321098765432109876543210
22516                                                 xx001111xxxxxxxx1110x0xxxxxxxxxx
22517                                                 sdot.  */
22518                                              return 2340;
22519                                            }
22520                                          else
22521                                            {
22522                                              /* 33222222222211111111110000000000
22523                                                 10987654321098765432109876543210
22524                                                 xx101111xxxxxxxx1110x0xxxxxxxxxx
22525                                                 udot.  */
22526                                              return 2339;
22527                                            }
22528                                        }
22529                                    }
22530                                }
22531                              else
22532                                {
22533                                  if (((word >> 13) & 0x1) == 0)
22534                                    {
22535                                      if (((word >> 14) & 0x1) == 0)
22536                                        {
22537                                          if (((word >> 23) & 0x1) == 0)
22538                                            {
22539                                              if (((word >> 29) & 0x1) == 0)
22540                                                {
22541                                                  /* 33222222222211111111110000000000
22542                                                     10987654321098765432109876543210
22543                                                     xx0011110xxxxxxx1001x0xxxxxxxxxx
22544                                                     fmul.  */
22545                                                  return 118;
22546                                                }
22547                                              else
22548                                                {
22549                                                  /* 33222222222211111111110000000000
22550                                                     10987654321098765432109876543210
22551                                                     xx1011110xxxxxxx1001x0xxxxxxxxxx
22552                                                     fmulx.  */
22553                                                  return 128;
22554                                                }
22555                                            }
22556                                          else
22557                                            {
22558                                              if (((word >> 29) & 0x1) == 0)
22559                                                {
22560                                                  /* 33222222222211111111110000000000
22561                                                     10987654321098765432109876543210
22562                                                     xx0011111xxxxxxx1001x0xxxxxxxxxx
22563                                                     fmul.  */
22564                                                  return 117;
22565                                                }
22566                                              else
22567                                                {
22568                                                  /* 33222222222211111111110000000000
22569                                                     10987654321098765432109876543210
22570                                                     xx1011111xxxxxxx1001x0xxxxxxxxxx
22571                                                     fmulx.  */
22572                                                  return 127;
22573                                                }
22574                                            }
22575                                        }
22576                                      else
22577                                        {
22578                                          if (((word >> 29) & 0x1) == 0)
22579                                            {
22580                                              /* 33222222222211111111110000000000
22581                                                 10987654321098765432109876543210
22582                                                 xx001111xxxxxxxx1101x0xxxxxxxxxx
22583                                                 sqrdmulh.  */
22584                                              return 112;
22585                                            }
22586                                          else
22587                                            {
22588                                              /* 33222222222211111111110000000000
22589                                                 10987654321098765432109876543210
22590                                                 xx101111xxxxxxxx1101x0xxxxxxxxxx
22591                                                 sqrdmlah.  */
22592                                              return 129;
22593                                            }
22594                                        }
22595                                    }
22596                                  else
22597                                    {
22598                                      if (((word >> 14) & 0x1) == 0)
22599                                        {
22600                                          if (((word >> 30) & 0x1) == 0)
22601                                            {
22602                                              /* 33222222222211111111110000000000
22603                                                 10987654321098765432109876543210
22604                                                 x0x01111xxxxxxxx1011x0xxxxxxxxxx
22605                                                 sqdmull.  */
22606                                              return 109;
22607                                            }
22608                                          else
22609                                            {
22610                                              /* 33222222222211111111110000000000
22611                                                 10987654321098765432109876543210
22612                                                 x1x01111xxxxxxxx1011x0xxxxxxxxxx
22613                                                 sqdmull2.  */
22614                                              return 110;
22615                                            }
22616                                        }
22617                                      else
22618                                        {
22619                                          if (((word >> 29) & 0x1) == 0)
22620                                            {
22621                                              if (((word >> 22) & 0x1) == 0)
22622                                                {
22623                                                  if (((word >> 23) & 0x1) == 0)
22624                                                    {
22625                                                      /* 33222222222211111111110000000000
22626                                                         10987654321098765432109876543210
22627                                                         xx00111100xxxxxx1111x0xxxxxxxxxx
22628                                                         sudot.  */
22629                                                      return 2418;
22630                                                    }
22631                                                  else
22632                                                    {
22633                                                      /* 33222222222211111111110000000000
22634                                                         10987654321098765432109876543210
22635                                                         xx00111110xxxxxx1111x0xxxxxxxxxx
22636                                                         usdot.  */
22637                                                      return 2417;
22638                                                    }
22639                                                }
22640                                              else
22641                                                {
22642                                                  if (((word >> 23) & 0x1) == 0)
22643                                                    {
22644                                                      /* 33222222222211111111110000000000
22645                                                         10987654321098765432109876543210
22646                                                         xx00111101xxxxxx1111x0xxxxxxxxxx
22647                                                         bfdot.  */
22648                                                      return 2429;
22649                                                    }
22650                                                  else
22651                                                    {
22652                                                      if (((word >> 30) & 0x1) == 0)
22653                                                        {
22654                                                          /* 33222222222211111111110000000000
22655                                                             10987654321098765432109876543210
22656                                                             x000111111xxxxxx1111x0xxxxxxxxxx
22657                                                             bfmlalb.  */
22658                                                          return 2437;
22659                                                        }
22660                                                      else
22661                                                        {
22662                                                          /* 33222222222211111111110000000000
22663                                                             10987654321098765432109876543210
22664                                                             x100111111xxxxxx1111x0xxxxxxxxxx
22665                                                             bfmlalt.  */
22666                                                          return 2436;
22667                                                        }
22668                                                    }
22669                                                }
22670                                            }
22671                                          else
22672                                            {
22673                                              /* 33222222222211111111110000000000
22674                                                 10987654321098765432109876543210
22675                                                 xx101111xxxxxxxx1111x0xxxxxxxxxx
22676                                                 sqrdmlsh.  */
22677                                              return 130;
22678                                            }
22679                                        }
22680                                    }
22681                                }
22682                            }
22683                          else
22684                            {
22685                              if (((word >> 11) & 0x1) == 0)
22686                                {
22687                                  if (((word >> 14) & 0x1) == 0)
22688                                    {
22689                                      if (((word >> 12) & 0x1) == 0)
22690                                        {
22691                                          if (((word >> 29) & 0x1) == 0)
22692                                            {
22693                                              /* 33222222222211111111110000000000
22694                                                 10987654321098765432109876543210
22695                                                 xx001111xxxxxxxx10x001xxxxxxxxxx
22696                                                 movi.  */
22697                                              return 135;
22698                                            }
22699                                          else
22700                                            {
22701                                              /* 33222222222211111111110000000000
22702                                                 10987654321098765432109876543210
22703                                                 xx101111xxxxxxxx10x001xxxxxxxxxx
22704                                                 mvni.  */
22705                                              return 143;
22706                                            }
22707                                        }
22708                                      else
22709                                        {
22710                                          if (((word >> 29) & 0x1) == 0)
22711                                            {
22712                                              /* 33222222222211111111110000000000
22713                                                 10987654321098765432109876543210
22714                                                 xx001111xxxxxxxx10x101xxxxxxxxxx
22715                                                 orr.  */
22716                                              return 136;
22717                                            }
22718                                          else
22719                                            {
22720                                              /* 33222222222211111111110000000000
22721                                                 10987654321098765432109876543210
22722                                                 xx101111xxxxxxxx10x101xxxxxxxxxx
22723                                                 bic.  */
22724                                              return 144;
22725                                            }
22726                                        }
22727                                    }
22728                                  else
22729                                    {
22730                                      if (((word >> 13) & 0x1) == 0)
22731                                        {
22732                                          if (((word >> 29) & 0x1) == 0)
22733                                            {
22734                                              /* 33222222222211111111110000000000
22735                                                 10987654321098765432109876543210
22736                                                 xx001111xxxxxxxx110x01xxxxxxxxxx
22737                                                 movi.  */
22738                                              return 137;
22739                                            }
22740                                          else
22741                                            {
22742                                              /* 33222222222211111111110000000000
22743                                                 10987654321098765432109876543210
22744                                                 xx101111xxxxxxxx110x01xxxxxxxxxx
22745                                                 mvni.  */
22746                                              return 145;
22747                                            }
22748                                        }
22749                                      else
22750                                        {
22751                                          if (((word >> 12) & 0x1) == 0)
22752                                            {
22753                                              if (((word >> 29) & 0x1) == 0)
22754                                                {
22755                                                  /* 33222222222211111111110000000000
22756                                                     10987654321098765432109876543210
22757                                                     xx001111xxxxxxxx111001xxxxxxxxxx
22758                                                     movi.  */
22759                                                  return 138;
22760                                                }
22761                                              else
22762                                                {
22763                                                  /* 33222222222211111111110000000000
22764                                                     10987654321098765432109876543210
22765                                                     xx101111xxxxxxxx111001xxxxxxxxxx
22766                                                     movi.  */
22767                                                  return 146;
22768                                                }
22769                                            }
22770                                          else
22771                                            {
22772                                              if (((word >> 29) & 0x1) == 0)
22773                                                {
22774                                                  /* 33222222222211111111110000000000
22775                                                     10987654321098765432109876543210
22776                                                     xx001111xxxxxxxx111101xxxxxxxxxx
22777                                                     fmov.  */
22778                                                  return 139;
22779                                                }
22780                                              else
22781                                                {
22782                                                  /* 33222222222211111111110000000000
22783                                                     10987654321098765432109876543210
22784                                                     xx101111xxxxxxxx111101xxxxxxxxxx
22785                                                     fmov.  */
22786                                                  return 148;
22787                                                }
22788                                            }
22789                                        }
22790                                    }
22791                                }
22792                              else
22793                                {
22794                                  if (((word >> 12) & 0x1) == 0)
22795                                    {
22796                                      if (((word >> 29) & 0x1) == 0)
22797                                        {
22798                                          if (((word >> 30) & 0x1) == 0)
22799                                            {
22800                                              /* 33222222222211111111110000000000
22801                                                 10987654321098765432109876543210
22802                                                 x0001111xxxxxxxx1xx011xxxxxxxxxx
22803                                                 rshrn.  */
22804                                              return 382;
22805                                            }
22806                                          else
22807                                            {
22808                                              /* 33222222222211111111110000000000
22809                                                 10987654321098765432109876543210
22810                                                 x1001111xxxxxxxx1xx011xxxxxxxxxx
22811                                                 rshrn2.  */
22812                                              return 383;
22813                                            }
22814                                        }
22815                                      else
22816                                        {
22817                                          if (((word >> 30) & 0x1) == 0)
22818                                            {
22819                                              /* 33222222222211111111110000000000
22820                                                 10987654321098765432109876543210
22821                                                 x0101111xxxxxxxx1xx011xxxxxxxxxx
22822                                                 sqrshrun.  */
22823                                              return 406;
22824                                            }
22825                                          else
22826                                            {
22827                                              /* 33222222222211111111110000000000
22828                                                 10987654321098765432109876543210
22829                                                 x1101111xxxxxxxx1xx011xxxxxxxxxx
22830                                                 sqrshrun2.  */
22831                                              return 407;
22832                                            }
22833                                        }
22834                                    }
22835                                  else
22836                                    {
22837                                      if (((word >> 13) & 0x1) == 0)
22838                                        {
22839                                          if (((word >> 29) & 0x1) == 0)
22840                                            {
22841                                              if (((word >> 30) & 0x1) == 0)
22842                                                {
22843                                                  /* 33222222222211111111110000000000
22844                                                     10987654321098765432109876543210
22845                                                     x0001111xxxxxxxx1x0111xxxxxxxxxx
22846                                                     sqrshrn.  */
22847                                                  return 386;
22848                                                }
22849                                              else
22850                                                {
22851                                                  /* 33222222222211111111110000000000
22852                                                     10987654321098765432109876543210
22853                                                     x1001111xxxxxxxx1x0111xxxxxxxxxx
22854                                                     sqrshrn2.  */
22855                                                  return 387;
22856                                                }
22857                                            }
22858                                          else
22859                                            {
22860                                              if (((word >> 30) & 0x1) == 0)
22861                                                {
22862                                                  /* 33222222222211111111110000000000
22863                                                     10987654321098765432109876543210
22864                                                     x0101111xxxxxxxx1x0111xxxxxxxxxx
22865                                                     uqrshrn.  */
22866                                                  return 410;
22867                                                }
22868                                              else
22869                                                {
22870                                                  /* 33222222222211111111110000000000
22871                                                     10987654321098765432109876543210
22872                                                     x1101111xxxxxxxx1x0111xxxxxxxxxx
22873                                                     uqrshrn2.  */
22874                                                  return 411;
22875                                                }
22876                                            }
22877                                        }
22878                                      else
22879                                        {
22880                                          if (((word >> 29) & 0x1) == 0)
22881                                            {
22882                                              /* 33222222222211111111110000000000
22883                                                 10987654321098765432109876543210
22884                                                 xx001111xxxxxxxx1x1111xxxxxxxxxx
22885                                                 fmov.  */
22886                                              return 140;
22887                                            }
22888                                          else
22889                                            {
22890                                              /* 33222222222211111111110000000000
22891                                                 10987654321098765432109876543210
22892                                                 xx101111xxxxxxxx1x1111xxxxxxxxxx
22893                                                 fcvtzu.  */
22894                                              return 418;
22895                                            }
22896                                        }
22897                                    }
22898                                }
22899                            }
22900                        }
22901                      else
22902                        {
22903                          if (((word >> 29) & 0x1) == 0)
22904                            {
22905                              if (((word >> 30) & 0x1) == 0)
22906                                {
22907                                  if (((word >> 21) & 0x1) == 0)
22908                                    {
22909                                      /* 33222222222211111111110000000000
22910                                         10987654321098765432109876543210
22911                                         x0011111xx0xxxxx1xxxxxxxxxxxxxxx
22912                                         fmsub.  */
22913                                      return 859;
22914                                    }
22915                                  else
22916                                    {
22917                                      /* 33222222222211111111110000000000
22918                                         10987654321098765432109876543210
22919                                         x0011111xx1xxxxx1xxxxxxxxxxxxxxx
22920                                         fnmsub.  */
22921                                      return 863;
22922                                    }
22923                                }
22924                              else
22925                                {
22926                                  if (((word >> 10) & 0x1) == 0)
22927                                    {
22928                                      if (((word >> 12) & 0x1) == 0)
22929                                        {
22930                                          /* 33222222222211111111110000000000
22931                                             10987654321098765432109876543210
22932                                             x1011111xxxxxxxx1xx0x0xxxxxxxxxx
22933                                             sqdmulh.  */
22934                                          return 428;
22935                                        }
22936                                      else
22937                                        {
22938                                          if (((word >> 13) & 0x1) == 0)
22939                                            {
22940                                              if (((word >> 14) & 0x1) == 0)
22941                                                {
22942                                                  if (((word >> 23) & 0x1) == 0)
22943                                                    {
22944                                                      /* 33222222222211111111110000000000
22945                                                         10987654321098765432109876543210
22946                                                         x10111110xxxxxxx1001x0xxxxxxxxxx
22947                                                         fmul.  */
22948                                                      return 435;
22949                                                    }
22950                                                  else
22951                                                    {
22952                                                      /* 33222222222211111111110000000000
22953                                                         10987654321098765432109876543210
22954                                                         x10111111xxxxxxx1001x0xxxxxxxxxx
22955                                                         fmul.  */
22956                                                      return 434;
22957                                                    }
22958                                                }
22959                                              else
22960                                                {
22961                                                  /* 33222222222211111111110000000000
22962                                                     10987654321098765432109876543210
22963                                                     x1011111xxxxxxxx1101x0xxxxxxxxxx
22964                                                     sqrdmulh.  */
22965                                                  return 429;
22966                                                }
22967                                            }
22968                                          else
22969                                            {
22970                                              /* 33222222222211111111110000000000
22971                                                 10987654321098765432109876543210
22972                                                 x1011111xxxxxxxx1x11x0xxxxxxxxxx
22973                                                 sqdmull.  */
22974                                              return 427;
22975                                            }
22976                                        }
22977                                    }
22978                                  else
22979                                    {
22980                                      if (((word >> 11) & 0x1) == 0)
22981                                        {
22982                                          if (((word >> 12) & 0x1) == 0)
22983                                            {
22984                                              /* 33222222222211111111110000000000
22985                                                 10987654321098765432109876543210
22986                                                 x1011111xxxxxxxx1xx001xxxxxxxxxx
22987                                                 scvtf.  */
22988                                              return 598;
22989                                            }
22990                                          else
22991                                            {
22992                                              /* 33222222222211111111110000000000
22993                                                 10987654321098765432109876543210
22994                                                 x1011111xxxxxxxx1xx101xxxxxxxxxx
22995                                                 sqshrn.  */
22996                                              return 596;
22997                                            }
22998                                        }
22999                                      else
23000                                        {
23001                                          if (((word >> 13) & 0x1) == 0)
23002                                            {
23003                                              /* 33222222222211111111110000000000
23004                                                 10987654321098765432109876543210
23005                                                 x1011111xxxxxxxx1x0x11xxxxxxxxxx
23006                                                 sqrshrn.  */
23007                                              return 597;
23008                                            }
23009                                          else
23010                                            {
23011                                              /* 33222222222211111111110000000000
23012                                                 10987654321098765432109876543210
23013                                                 x1011111xxxxxxxx1x1x11xxxxxxxxxx
23014                                                 fcvtzs.  */
23015                                              return 600;
23016                                            }
23017                                        }
23018                                    }
23019                                }
23020                            }
23021                          else
23022                            {
23023                              if (((word >> 10) & 0x1) == 0)
23024                                {
23025                                  if (((word >> 13) & 0x1) == 0)
23026                                    {
23027                                      if (((word >> 14) & 0x1) == 0)
23028                                        {
23029                                          if (((word >> 23) & 0x1) == 0)
23030                                            {
23031                                              /* 33222222222211111111110000000000
23032                                                 10987654321098765432109876543210
23033                                                 xx1111110xxxxxxx100xx0xxxxxxxxxx
23034                                                 fmulx.  */
23035                                              return 437;
23036                                            }
23037                                          else
23038                                            {
23039                                              /* 33222222222211111111110000000000
23040                                                 10987654321098765432109876543210
23041                                                 xx1111111xxxxxxx100xx0xxxxxxxxxx
23042                                                 fmulx.  */
23043                                              return 436;
23044                                            }
23045                                        }
23046                                      else
23047                                        {
23048                                          /* 33222222222211111111110000000000
23049                                             10987654321098765432109876543210
23050                                             xx111111xxxxxxxx110xx0xxxxxxxxxx
23051                                             sqrdmlah.  */
23052                                          return 438;
23053                                        }
23054                                    }
23055                                  else
23056                                    {
23057                                      /* 33222222222211111111110000000000
23058                                         10987654321098765432109876543210
23059                                         xx111111xxxxxxxx1x1xx0xxxxxxxxxx
23060                                         sqrdmlsh.  */
23061                                      return 439;
23062                                    }
23063                                }
23064                              else
23065                                {
23066                                  if (((word >> 11) & 0x1) == 0)
23067                                    {
23068                                      if (((word >> 12) & 0x1) == 0)
23069                                        {
23070                                          if (((word >> 13) & 0x1) == 0)
23071                                            {
23072                                              /* 33222222222211111111110000000000
23073                                                 10987654321098765432109876543210
23074                                                 xx111111xxxxxxxx1x0001xxxxxxxxxx
23075                                                 sqshrun.  */
23076                                              return 610;
23077                                            }
23078                                          else
23079                                            {
23080                                              /* 33222222222211111111110000000000
23081                                                 10987654321098765432109876543210
23082                                                 xx111111xxxxxxxx1x1001xxxxxxxxxx
23083                                                 ucvtf.  */
23084                                              return 614;
23085                                            }
23086                                        }
23087                                      else
23088                                        {
23089                                          /* 33222222222211111111110000000000
23090                                             10987654321098765432109876543210
23091                                             xx111111xxxxxxxx1xx101xxxxxxxxxx
23092                                             uqshrn.  */
23093                                          return 612;
23094                                        }
23095                                    }
23096                                  else
23097                                    {
23098                                      if (((word >> 12) & 0x1) == 0)
23099                                        {
23100                                          /* 33222222222211111111110000000000
23101                                             10987654321098765432109876543210
23102                                             xx111111xxxxxxxx1xx011xxxxxxxxxx
23103                                             sqrshrun.  */
23104                                          return 611;
23105                                        }
23106                                      else
23107                                        {
23108                                          if (((word >> 13) & 0x1) == 0)
23109                                            {
23110                                              /* 33222222222211111111110000000000
23111                                                 10987654321098765432109876543210
23112                                                 xx111111xxxxxxxx1x0111xxxxxxxxxx
23113                                                 uqrshrn.  */
23114                                              return 613;
23115                                            }
23116                                          else
23117                                            {
23118                                              /* 33222222222211111111110000000000
23119                                                 10987654321098765432109876543210
23120                                                 xx111111xxxxxxxx1x1111xxxxxxxxxx
23121                                                 fcvtzu.  */
23122                                              return 616;
23123                                            }
23124                                        }
23125                                    }
23126                                }
23127                            }
23128                        }
23129                    }
23130                }
23131            }
23132        }
23133    }
23134}
23135
23136/* Lookup opcode WORD in the opcode table.  N.B. all alias
23137   opcodes are ignored here.  */
23138
23139const aarch64_opcode *
23140aarch64_opcode_lookup (uint32_t word)
23141{
23142  return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);
23143}
23144
23145const aarch64_opcode *
23146aarch64_find_next_opcode (const aarch64_opcode *opcode)
23147{
23148  /* Use the index as the key to locate the next opcode.  */
23149  int key = opcode - aarch64_opcode_table;
23150  int value;
23151  switch (key)
23152    {
23153    case 12: value = 19; break;	/* add --> addg.  */
23154    case 19: return NULL;		/* addg --> NULL.  */
23155    case 16: value = 20; break;	/* sub --> subg.  */
23156    case 20: return NULL;		/* subg --> NULL.  */
23157    case 970: value = 974; break;	/* stnp --> stp.  */
23158    case 974: return NULL;		/* stp --> NULL.  */
23159    case 968: value = 969; break;	/* stllrb --> stllrh.  */
23160    case 969: return NULL;		/* stllrh --> NULL.  */
23161    case 971: value = 975; break;	/* ldnp --> ldp.  */
23162    case 975: return NULL;		/* ldp --> NULL.  */
23163    case 1625: value = 1626; break;	/* ldff1b --> ldff1b.  */
23164    case 1626: return NULL;		/* ldff1b --> NULL.  */
23165    case 1681: value = 1682; break;	/* ldff1sw --> ldff1sw.  */
23166    case 1682: return NULL;		/* ldff1sw --> NULL.  */
23167    case 1629: value = 1630; break;	/* ldff1b --> ldff1b.  */
23168    case 1630: return NULL;		/* ldff1b --> NULL.  */
23169    case 1648: value = 1649; break;	/* ldff1h --> ldff1h.  */
23170    case 1649: return NULL;		/* ldff1h --> NULL.  */
23171    case 1627: value = 1628; break;	/* ldff1b --> ldff1b.  */
23172    case 1628: return NULL;		/* ldff1b --> NULL.  */
23173    case 1646: value = 1647; break;	/* ldff1h --> ldff1h.  */
23174    case 1647: return NULL;		/* ldff1h --> NULL.  */
23175    case 1631: value = 1632; break;	/* ldff1b --> ldff1b.  */
23176    case 1632: return NULL;		/* ldff1b --> NULL.  */
23177    case 1650: value = 1651; break;	/* ldff1h --> ldff1h.  */
23178    case 1651: return NULL;		/* ldff1h --> NULL.  */
23179    case 1671: value = 1672; break;	/* ldff1sh --> ldff1sh.  */
23180    case 1672: return NULL;		/* ldff1sh --> NULL.  */
23181    case 1659: value = 1660; break;	/* ldff1sb --> ldff1sb.  */
23182    case 1660: return NULL;		/* ldff1sb --> NULL.  */
23183    case 1690: value = 1691; break;	/* ldff1w --> ldff1w.  */
23184    case 1691: return NULL;		/* ldff1w --> NULL.  */
23185    case 1663: value = 1664; break;	/* ldff1sb --> ldff1sb.  */
23186    case 1664: return NULL;		/* ldff1sb --> NULL.  */
23187    case 1673: value = 1674; break;	/* ldff1sh --> ldff1sh.  */
23188    case 1674: return NULL;		/* ldff1sh --> NULL.  */
23189    case 1661: value = 1662; break;	/* ldff1sb --> ldff1sb.  */
23190    case 1662: return NULL;		/* ldff1sb --> NULL.  */
23191    case 1692: value = 1693; break;	/* ldff1w --> ldff1w.  */
23192    case 1693: return NULL;		/* ldff1w --> NULL.  */
23193    case 1637: value = 1638; break;	/* ldff1d --> ldff1d.  */
23194    case 1638: return NULL;		/* ldff1d --> NULL.  */
23195    case 810: value = 811; break;	/* xaflag --> axflag.  */
23196    case 811: value = 1189; break;	/* axflag --> tcommit.  */
23197    case 1189: value = 1192; break;	/* tcommit --> msr.  */
23198    case 1192: value = 1193; break;	/* msr --> hint.  */
23199    case 1193: value = 1209; break;	/* hint --> clrex.  */
23200    case 1209: value = 1210; break;	/* clrex --> dsb.  */
23201    case 1210: value = 1213; break;	/* dsb --> dmb.  */
23202    case 1213: value = 1214; break;	/* dmb --> isb.  */
23203    case 1214: value = 1215; break;	/* isb --> sb.  */
23204    case 1215: value = 1216; break;	/* sb --> sys.  */
23205    case 1216: value = 1224; break;	/* sys --> cfinv.  */
23206    case 1224: value = 1225; break;	/* cfinv --> msr.  */
23207    case 1225: value = 2390; break;	/* msr --> dgh.  */
23208    case 2390: return NULL;		/* dgh --> NULL.  */
23209    case 1188: value = 1190; break;	/* tstart --> ttest.  */
23210    case 1190: value = 1226; break;	/* ttest --> sysl.  */
23211    case 1226: value = 1227; break;	/* sysl --> mrs.  */
23212    case 1227: return NULL;		/* mrs --> NULL.  */
23213    case 440: value = 441; break;	/* st4 --> st1.  */
23214    case 441: value = 442; break;	/* st1 --> st2.  */
23215    case 442: value = 443; break;	/* st2 --> st3.  */
23216    case 443: return NULL;		/* st3 --> NULL.  */
23217    case 448: value = 449; break;	/* st4 --> st1.  */
23218    case 449: value = 450; break;	/* st1 --> st2.  */
23219    case 450: value = 451; break;	/* st2 --> st3.  */
23220    case 451: return NULL;		/* st3 --> NULL.  */
23221    case 444: value = 445; break;	/* ld4 --> ld1.  */
23222    case 445: value = 446; break;	/* ld1 --> ld2.  */
23223    case 446: value = 447; break;	/* ld2 --> ld3.  */
23224    case 447: return NULL;		/* ld3 --> NULL.  */
23225    case 460: value = 462; break;	/* ld1 --> ld1r.  */
23226    case 462: return NULL;		/* ld1r --> NULL.  */
23227    case 464: value = 466; break;	/* ld2 --> ld2r.  */
23228    case 466: return NULL;		/* ld2r --> NULL.  */
23229    case 461: value = 463; break;	/* ld3 --> ld3r.  */
23230    case 463: return NULL;		/* ld3r --> NULL.  */
23231    case 465: value = 467; break;	/* ld4 --> ld4r.  */
23232    case 467: return NULL;		/* ld4r --> NULL.  */
23233    case 452: value = 453; break;	/* ld4 --> ld1.  */
23234    case 453: value = 454; break;	/* ld1 --> ld2.  */
23235    case 454: value = 455; break;	/* ld2 --> ld3.  */
23236    case 455: return NULL;		/* ld3 --> NULL.  */
23237    case 472: value = 474; break;	/* ld1 --> ld1r.  */
23238    case 474: return NULL;		/* ld1r --> NULL.  */
23239    case 473: value = 475; break;	/* ld3 --> ld3r.  */
23240    case 475: return NULL;		/* ld3r --> NULL.  */
23241    case 476: value = 478; break;	/* ld2 --> ld2r.  */
23242    case 478: return NULL;		/* ld2r --> NULL.  */
23243    case 477: value = 479; break;	/* ld4 --> ld4r.  */
23244    case 479: return NULL;		/* ld4r --> NULL.  */
23245    case 763: value = 764; break;	/* fcvtzs --> fcvtzs.  */
23246    case 764: return NULL;		/* fcvtzs --> NULL.  */
23247    case 759: value = 760; break;	/* scvtf --> scvtf.  */
23248    case 760: return NULL;		/* scvtf --> NULL.  */
23249    case 765: value = 766; break;	/* fcvtzu --> fcvtzu.  */
23250    case 766: return NULL;		/* fcvtzu --> NULL.  */
23251    case 761: value = 762; break;	/* ucvtf --> ucvtf.  */
23252    case 762: return NULL;		/* ucvtf --> NULL.  */
23253    case 767: value = 768; break;	/* fcvtns --> fcvtns.  */
23254    case 768: return NULL;		/* fcvtns --> NULL.  */
23255    case 787: value = 788; break;	/* fcvtms --> fcvtms.  */
23256    case 788: return NULL;		/* fcvtms --> NULL.  */
23257    case 783: value = 784; break;	/* fcvtps --> fcvtps.  */
23258    case 784: return NULL;		/* fcvtps --> NULL.  */
23259    case 791: value = 792; break;	/* fcvtzs --> fcvtzs.  */
23260    case 792: return NULL;		/* fcvtzs --> NULL.  */
23261    case 775: value = 776; break;	/* fcvtas --> fcvtas.  */
23262    case 776: return NULL;		/* fcvtas --> NULL.  */
23263    case 771: value = 772; break;	/* scvtf --> scvtf.  */
23264    case 772: return NULL;		/* scvtf --> NULL.  */
23265    case 779: value = 780; break;	/* fmov --> fmov.  */
23266    case 780: return NULL;		/* fmov --> NULL.  */
23267    case 769: value = 770; break;	/* fcvtnu --> fcvtnu.  */
23268    case 770: return NULL;		/* fcvtnu --> NULL.  */
23269    case 789: value = 790; break;	/* fcvtmu --> fcvtmu.  */
23270    case 790: return NULL;		/* fcvtmu --> NULL.  */
23271    case 785: value = 786; break;	/* fcvtpu --> fcvtpu.  */
23272    case 786: return NULL;		/* fcvtpu --> NULL.  */
23273    case 793: value = 794; break;	/* fcvtzu --> fcvtzu.  */
23274    case 794: return NULL;		/* fcvtzu --> NULL.  */
23275    case 777: value = 778; break;	/* fcvtau --> fcvtau.  */
23276    case 778: return NULL;		/* fcvtau --> NULL.  */
23277    case 773: value = 774; break;	/* ucvtf --> ucvtf.  */
23278    case 774: return NULL;		/* ucvtf --> NULL.  */
23279    case 781: value = 782; break;	/* fmov --> fmov.  */
23280    case 782: return NULL;		/* fmov --> NULL.  */
23281    case 816: value = 817; break;	/* fmov --> fmov.  */
23282    case 817: return NULL;		/* fmov --> NULL.  */
23283    case 825: value = 826; break;	/* frintn --> frintn.  */
23284    case 826: return NULL;		/* frintn --> NULL.  */
23285    case 820: value = 821; break;	/* fneg --> fneg.  */
23286    case 821: return NULL;		/* fneg --> NULL.  */
23287    case 829: value = 830; break;	/* frintm --> frintm.  */
23288    case 830: return NULL;		/* frintm --> NULL.  */
23289    case 818: value = 819; break;	/* fabs --> fabs.  */
23290    case 819: return NULL;		/* fabs --> NULL.  */
23291    case 827: value = 828; break;	/* frintp --> frintp.  */
23292    case 828: return NULL;		/* frintp --> NULL.  */
23293    case 822: value = 823; break;	/* fsqrt --> fsqrt.  */
23294    case 823: return NULL;		/* fsqrt --> NULL.  */
23295    case 831: value = 832; break;	/* frintz --> frintz.  */
23296    case 832: return NULL;		/* frintz --> NULL.  */
23297    case 824: value = 2433; break;	/* fcvt --> bfcvt.  */
23298    case 2433: return NULL;		/* bfcvt --> NULL.  */
23299    case 833: value = 834; break;	/* frinta --> frinta.  */
23300    case 834: return NULL;		/* frinta --> NULL.  */
23301    case 835: value = 836; break;	/* frintx --> frintx.  */
23302    case 836: return NULL;		/* frintx --> NULL.  */
23303    case 837: value = 838; break;	/* frinti --> frinti.  */
23304    case 838: return NULL;		/* frinti --> NULL.  */
23305    case 802: value = 803; break;	/* fcmp --> fcmp.  */
23306    case 803: return NULL;		/* fcmp --> NULL.  */
23307    case 804: value = 805; break;	/* fcmpe --> fcmpe.  */
23308    case 805: return NULL;		/* fcmpe --> NULL.  */
23309    case 806: value = 807; break;	/* fcmp --> fcmp.  */
23310    case 807: return NULL;		/* fcmp --> NULL.  */
23311    case 808: value = 809; break;	/* fcmpe --> fcmpe.  */
23312    case 809: return NULL;		/* fcmpe --> NULL.  */
23313    case 865: value = 866; break;	/* fmov --> fmov.  */
23314    case 866: return NULL;		/* fmov --> NULL.  */
23315    case 839: value = 840; break;	/* fmul --> fmul.  */
23316    case 840: return NULL;		/* fmul --> NULL.  */
23317    case 855: value = 856; break;	/* fnmul --> fnmul.  */
23318    case 856: return NULL;		/* fnmul --> NULL.  */
23319    case 847: value = 848; break;	/* fmax --> fmax.  */
23320    case 848: return NULL;		/* fmax --> NULL.  */
23321    case 843: value = 844; break;	/* fadd --> fadd.  */
23322    case 844: return NULL;		/* fadd --> NULL.  */
23323    case 851: value = 852; break;	/* fmaxnm --> fmaxnm.  */
23324    case 852: return NULL;		/* fmaxnm --> NULL.  */
23325    case 841: value = 842; break;	/* fdiv --> fdiv.  */
23326    case 842: return NULL;		/* fdiv --> NULL.  */
23327    case 849: value = 850; break;	/* fmin --> fmin.  */
23328    case 850: return NULL;		/* fmin --> NULL.  */
23329    case 845: value = 846; break;	/* fsub --> fsub.  */
23330    case 846: return NULL;		/* fsub --> NULL.  */
23331    case 853: value = 854; break;	/* fminnm --> fminnm.  */
23332    case 854: return NULL;		/* fminnm --> NULL.  */
23333    case 798: value = 799; break;	/* fccmp --> fccmp.  */
23334    case 799: return NULL;		/* fccmp --> NULL.  */
23335    case 800: value = 801; break;	/* fccmpe --> fccmpe.  */
23336    case 801: return NULL;		/* fccmpe --> NULL.  */
23337    case 867: value = 868; break;	/* fcsel --> fcsel.  */
23338    case 868: return NULL;		/* fcsel --> NULL.  */
23339    case 133: value = 374; break;	/* movi --> sshr.  */
23340    case 374: value = 376; break;	/* sshr --> srshr.  */
23341    case 376: return NULL;		/* srshr --> NULL.  */
23342    case 141: value = 396; break;	/* mvni --> ushr.  */
23343    case 396: value = 398; break;	/* ushr --> urshr.  */
23344    case 398: value = 400; break;	/* urshr --> sri.  */
23345    case 400: value = 402; break;	/* sri --> sqshlu.  */
23346    case 402: return NULL;		/* sqshlu --> NULL.  */
23347    case 134: value = 375; break;	/* orr --> ssra.  */
23348    case 375: value = 377; break;	/* ssra --> srsra.  */
23349    case 377: value = 378; break;	/* srsra --> shl.  */
23350    case 378: value = 379; break;	/* shl --> sqshl.  */
23351    case 379: return NULL;		/* sqshl --> NULL.  */
23352    case 142: value = 397; break;	/* bic --> usra.  */
23353    case 397: value = 399; break;	/* usra --> ursra.  */
23354    case 399: value = 401; break;	/* ursra --> sli.  */
23355    case 401: value = 403; break;	/* sli --> uqshl.  */
23356    case 403: return NULL;		/* uqshl --> NULL.  */
23357    case 857: value = 858; break;	/* fmadd --> fmadd.  */
23358    case 858: return NULL;		/* fmadd --> NULL.  */
23359    case 861: value = 862; break;	/* fnmadd --> fnmadd.  */
23360    case 862: return NULL;		/* fnmadd --> NULL.  */
23361    case 135: value = 380; break;	/* movi --> shrn.  */
23362    case 380: value = 381; break;	/* shrn --> shrn2.  */
23363    case 381: value = 388; break;	/* shrn2 --> sshll.  */
23364    case 388: value = 390; break;	/* sshll --> sshll2.  */
23365    case 390: return NULL;		/* sshll2 --> NULL.  */
23366    case 143: value = 404; break;	/* mvni --> sqshrun.  */
23367    case 404: value = 405; break;	/* sqshrun --> sqshrun2.  */
23368    case 405: value = 412; break;	/* sqshrun2 --> ushll.  */
23369    case 412: value = 414; break;	/* ushll --> ushll2.  */
23370    case 414: return NULL;		/* ushll2 --> NULL.  */
23371    case 136: value = 384; break;	/* orr --> sqshrn.  */
23372    case 384: value = 385; break;	/* sqshrn --> sqshrn2.  */
23373    case 385: return NULL;		/* sqshrn2 --> NULL.  */
23374    case 144: value = 408; break;	/* bic --> uqshrn.  */
23375    case 408: value = 409; break;	/* uqshrn --> uqshrn2.  */
23376    case 409: return NULL;		/* uqshrn2 --> NULL.  */
23377    case 138: value = 392; break;	/* movi --> scvtf.  */
23378    case 392: value = 393; break;	/* scvtf --> scvtf.  */
23379    case 393: return NULL;		/* scvtf --> NULL.  */
23380    case 146: value = 147; break;	/* movi --> movi.  */
23381    case 147: value = 416; break;	/* movi --> ucvtf.  */
23382    case 416: value = 417; break;	/* ucvtf --> ucvtf.  */
23383    case 417: return NULL;		/* ucvtf --> NULL.  */
23384    case 140: value = 394; break;	/* fmov --> fcvtzs.  */
23385    case 394: value = 395; break;	/* fcvtzs --> fcvtzs.  */
23386    case 395: return NULL;		/* fcvtzs --> NULL.  */
23387    case 418: value = 419; break;	/* fcvtzu --> fcvtzu.  */
23388    case 419: return NULL;		/* fcvtzu --> NULL.  */
23389    case 859: value = 860; break;	/* fmsub --> fmsub.  */
23390    case 860: return NULL;		/* fmsub --> NULL.  */
23391    case 863: value = 864; break;	/* fnmsub --> fnmsub.  */
23392    case 864: return NULL;		/* fnmsub --> NULL.  */
23393    case 598: value = 599; break;	/* scvtf --> scvtf.  */
23394    case 599: return NULL;		/* scvtf --> NULL.  */
23395    case 600: value = 601; break;	/* fcvtzs --> fcvtzs.  */
23396    case 601: return NULL;		/* fcvtzs --> NULL.  */
23397    case 614: value = 615; break;	/* ucvtf --> ucvtf.  */
23398    case 615: return NULL;		/* ucvtf --> NULL.  */
23399    case 616: value = 617; break;	/* fcvtzu --> fcvtzu.  */
23400    case 617: return NULL;		/* fcvtzu --> NULL.  */
23401    default: return NULL;
23402    }
23403
23404  return aarch64_opcode_table + value;
23405}
23406
23407const aarch64_opcode *
23408aarch64_find_alias_opcode (const aarch64_opcode *opcode)
23409{
23410  /* Use the index as the key to locate the alias opcode.  */
23411  int key = opcode - aarch64_opcode_table;
23412  int value;
23413  switch (key)
23414    {
23415    case 2: value = 3; break;	/* sbc --> ngc.  */
23416    case 4: value = 5; break;	/* sbcs --> ngcs.  */
23417    case 7: value = 8; break;	/* adds --> cmn.  */
23418    case 10: value = 11; break;	/* subs --> cmp.  */
23419    case 12: value = 13; break;	/* add --> mov.  */
23420    case 14: value = 15; break;	/* adds --> cmn.  */
23421    case 17: value = 18; break;	/* subs --> cmp.  */
23422    case 22: value = 23; break;	/* adds --> cmn.  */
23423    case 24: value = 25; break;	/* sub --> neg.  */
23424    case 26: value = 27; break;	/* subs --> cmp.  */
23425    case 152: value = 153; break;	/* umov --> mov.  */
23426    case 154: value = 155; break;	/* ins --> mov.  */
23427    case 156: value = 157; break;	/* ins --> mov.  */
23428    case 242: value = 243; break;	/* not --> mvn.  */
23429    case 317: value = 318; break;	/* orr --> mov.  */
23430    case 388: value = 389; break;	/* sshll --> sxtl.  */
23431    case 390: value = 391; break;	/* sshll2 --> sxtl2.  */
23432    case 412: value = 413; break;	/* ushll --> uxtl.  */
23433    case 414: value = 415; break;	/* ushll2 --> uxtl2.  */
23434    case 535: value = 536; break;	/* dup --> mov.  */
23435    case 618: value = 623; break;	/* sbfm --> sxtw.  */
23436    case 625: value = 627; break;	/* bfm --> bfc.  */
23437    case 629: value = 633; break;	/* ubfm --> uxth.  */
23438    case 663: value = 665; break;	/* csinc --> cset.  */
23439    case 666: value = 668; break;	/* csinv --> csetm.  */
23440    case 669: value = 670; break;	/* csneg --> cneg.  */
23441    case 688: value = 688; break;	/* rev --> rev.  */
23442    case 713: value = 714; break;	/* lslv --> lsl.  */
23443    case 715: value = 716; break;	/* lsrv --> lsr.  */
23444    case 717: value = 718; break;	/* asrv --> asr.  */
23445    case 719: value = 720; break;	/* rorv --> ror.  */
23446    case 722: value = 723; break;	/* subps --> cmpp.  */
23447    case 735: value = 736; break;	/* madd --> mul.  */
23448    case 737: value = 738; break;	/* msub --> mneg.  */
23449    case 739: value = 740; break;	/* smaddl --> smull.  */
23450    case 741: value = 742; break;	/* smsubl --> smnegl.  */
23451    case 744: value = 745; break;	/* umaddl --> umull.  */
23452    case 746: value = 747; break;	/* umsubl --> umnegl.  */
23453    case 757: value = 758; break;	/* extr --> ror.  */
23454    case 990: value = 991; break;	/* and --> bic.  */
23455    case 992: value = 993; break;	/* orr --> mov.  */
23456    case 995: value = 996; break;	/* ands --> tst.  */
23457    case 999: value = 1001; break;	/* orr --> uxtw.  */
23458    case 1002: value = 1003; break;	/* orn --> mvn.  */
23459    case 1006: value = 1007; break;	/* ands --> tst.  */
23460    case 1037: value = 1133; break;	/* ldaddb --> staddb.  */
23461    case 1038: value = 1134; break;	/* ldaddh --> staddh.  */
23462    case 1039: value = 1135; break;	/* ldadd --> stadd.  */
23463    case 1041: value = 1136; break;	/* ldaddlb --> staddlb.  */
23464    case 1044: value = 1137; break;	/* ldaddlh --> staddlh.  */
23465    case 1047: value = 1138; break;	/* ldaddl --> staddl.  */
23466    case 1049: value = 1139; break;	/* ldclrb --> stclrb.  */
23467    case 1050: value = 1140; break;	/* ldclrh --> stclrh.  */
23468    case 1051: value = 1141; break;	/* ldclr --> stclr.  */
23469    case 1053: value = 1142; break;	/* ldclrlb --> stclrlb.  */
23470    case 1056: value = 1143; break;	/* ldclrlh --> stclrlh.  */
23471    case 1059: value = 1144; break;	/* ldclrl --> stclrl.  */
23472    case 1061: value = 1145; break;	/* ldeorb --> steorb.  */
23473    case 1062: value = 1146; break;	/* ldeorh --> steorh.  */
23474    case 1063: value = 1147; break;	/* ldeor --> steor.  */
23475    case 1065: value = 1148; break;	/* ldeorlb --> steorlb.  */
23476    case 1068: value = 1149; break;	/* ldeorlh --> steorlh.  */
23477    case 1071: value = 1150; break;	/* ldeorl --> steorl.  */
23478    case 1073: value = 1151; break;	/* ldsetb --> stsetb.  */
23479    case 1074: value = 1152; break;	/* ldseth --> stseth.  */
23480    case 1075: value = 1153; break;	/* ldset --> stset.  */
23481    case 1077: value = 1154; break;	/* ldsetlb --> stsetlb.  */
23482    case 1080: value = 1155; break;	/* ldsetlh --> stsetlh.  */
23483    case 1083: value = 1156; break;	/* ldsetl --> stsetl.  */
23484    case 1085: value = 1157; break;	/* ldsmaxb --> stsmaxb.  */
23485    case 1086: value = 1158; break;	/* ldsmaxh --> stsmaxh.  */
23486    case 1087: value = 1159; break;	/* ldsmax --> stsmax.  */
23487    case 1089: value = 1160; break;	/* ldsmaxlb --> stsmaxlb.  */
23488    case 1092: value = 1161; break;	/* ldsmaxlh --> stsmaxlh.  */
23489    case 1095: value = 1162; break;	/* ldsmaxl --> stsmaxl.  */
23490    case 1097: value = 1163; break;	/* ldsminb --> stsminb.  */
23491    case 1098: value = 1164; break;	/* ldsminh --> stsminh.  */
23492    case 1099: value = 1165; break;	/* ldsmin --> stsmin.  */
23493    case 1101: value = 1166; break;	/* ldsminlb --> stsminlb.  */
23494    case 1104: value = 1167; break;	/* ldsminlh --> stsminlh.  */
23495    case 1107: value = 1168; break;	/* ldsminl --> stsminl.  */
23496    case 1109: value = 1169; break;	/* ldumaxb --> stumaxb.  */
23497    case 1110: value = 1170; break;	/* ldumaxh --> stumaxh.  */
23498    case 1111: value = 1171; break;	/* ldumax --> stumax.  */
23499    case 1113: value = 1172; break;	/* ldumaxlb --> stumaxlb.  */
23500    case 1116: value = 1173; break;	/* ldumaxlh --> stumaxlh.  */
23501    case 1119: value = 1174; break;	/* ldumaxl --> stumaxl.  */
23502    case 1121: value = 1175; break;	/* lduminb --> stuminb.  */
23503    case 1122: value = 1176; break;	/* lduminh --> stuminh.  */
23504    case 1123: value = 1177; break;	/* ldumin --> stumin.  */
23505    case 1125: value = 1178; break;	/* lduminlb --> stuminlb.  */
23506    case 1128: value = 1179; break;	/* lduminlh --> stuminlh.  */
23507    case 1131: value = 1180; break;	/* lduminl --> stuminl.  */
23508    case 1181: value = 1182; break;	/* movn --> mov.  */
23509    case 1183: value = 1184; break;	/* movz --> mov.  */
23510    case 1193: value = 1235; break;	/* hint --> autibsp.  */
23511    case 1210: value = 1212; break;	/* dsb --> pssbb.  */
23512    case 1216: value = 1223; break;	/* sys --> cpp.  */
23513    case 1283: value = 2033; break;	/* and --> bic.  */
23514    case 1285: value = 1266; break;	/* and --> mov.  */
23515    case 1286: value = 1270; break;	/* ands --> movs.  */
23516    case 1321: value = 2034; break;	/* cmpge --> cmple.  */
23517    case 1324: value = 2037; break;	/* cmpgt --> cmplt.  */
23518    case 1326: value = 2035; break;	/* cmphi --> cmplo.  */
23519    case 1329: value = 2036; break;	/* cmphs --> cmpls.  */
23520    case 1351: value = 1263; break;	/* cpy --> mov.  */
23521    case 1352: value = 1265; break;	/* cpy --> mov.  */
23522    case 1353: value = 2044; break;	/* cpy --> fmov.  */
23523    case 1365: value = 1258; break;	/* dup --> mov.  */
23524    case 1366: value = 1260; break;	/* dup --> mov.  */
23525    case 1367: value = 2043; break;	/* dup --> fmov.  */
23526    case 1368: value = 1261; break;	/* dupm --> mov.  */
23527    case 1370: value = 2038; break;	/* eor --> eon.  */
23528    case 1372: value = 1271; break;	/* eor --> not.  */
23529    case 1373: value = 1272; break;	/* eors --> nots.  */
23530    case 1378: value = 2039; break;	/* facge --> facle.  */
23531    case 1379: value = 2040; break;	/* facgt --> faclt.  */
23532    case 1392: value = 2041; break;	/* fcmge --> fcmle.  */
23533    case 1394: value = 2042; break;	/* fcmgt --> fcmlt.  */
23534    case 1400: value = 1255; break;	/* fcpy --> fmov.  */
23535    case 1423: value = 1254; break;	/* fdup --> fmov.  */
23536    case 1754: value = 1256; break;	/* orr --> mov.  */
23537    case 1755: value = 2045; break;	/* orr --> orn.  */
23538    case 1757: value = 1259; break;	/* orr --> mov.  */
23539    case 1758: value = 1269; break;	/* orrs --> movs.  */
23540    case 1820: value = 1264; break;	/* sel --> mov.  */
23541    case 1821: value = 1267; break;	/* sel --> mov.  */
23542    default: return NULL;
23543    }
23544
23545  return aarch64_opcode_table + value;
23546}
23547
23548const aarch64_opcode *
23549aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)
23550{
23551  /* Use the index as the key to locate the next opcode.  */
23552  int key = opcode - aarch64_opcode_table;
23553  int value;
23554  switch (key)
23555    {
23556    case 3: value = 2; break;	/* ngc --> sbc.  */
23557    case 5: value = 4; break;	/* ngcs --> sbcs.  */
23558    case 8: value = 7; break;	/* cmn --> adds.  */
23559    case 11: value = 10; break;	/* cmp --> subs.  */
23560    case 13: value = 12; break;	/* mov --> add.  */
23561    case 15: value = 14; break;	/* cmn --> adds.  */
23562    case 18: value = 17; break;	/* cmp --> subs.  */
23563    case 23: value = 22; break;	/* cmn --> adds.  */
23564    case 25: value = 24; break;	/* neg --> sub.  */
23565    case 27: value = 28; break;	/* cmp --> negs.  */
23566    case 28: value = 26; break;	/* negs --> subs.  */
23567    case 153: value = 152; break;	/* mov --> umov.  */
23568    case 155: value = 154; break;	/* mov --> ins.  */
23569    case 157: value = 156; break;	/* mov --> ins.  */
23570    case 243: value = 242; break;	/* mvn --> not.  */
23571    case 318: value = 317; break;	/* mov --> orr.  */
23572    case 389: value = 388; break;	/* sxtl --> sshll.  */
23573    case 391: value = 390; break;	/* sxtl2 --> sshll2.  */
23574    case 413: value = 412; break;	/* uxtl --> ushll.  */
23575    case 415: value = 414; break;	/* uxtl2 --> ushll2.  */
23576    case 536: value = 535; break;	/* mov --> dup.  */
23577    case 623: value = 622; break;	/* sxtw --> sxth.  */
23578    case 622: value = 621; break;	/* sxth --> sxtb.  */
23579    case 621: value = 624; break;	/* sxtb --> asr.  */
23580    case 624: value = 620; break;	/* asr --> sbfx.  */
23581    case 620: value = 619; break;	/* sbfx --> sbfiz.  */
23582    case 619: value = 618; break;	/* sbfiz --> sbfm.  */
23583    case 627: value = 628; break;	/* bfc --> bfxil.  */
23584    case 628: value = 626; break;	/* bfxil --> bfi.  */
23585    case 626: value = 625; break;	/* bfi --> bfm.  */
23586    case 633: value = 632; break;	/* uxth --> uxtb.  */
23587    case 632: value = 635; break;	/* uxtb --> lsr.  */
23588    case 635: value = 634; break;	/* lsr --> lsl.  */
23589    case 634: value = 631; break;	/* lsl --> ubfx.  */
23590    case 631: value = 630; break;	/* ubfx --> ubfiz.  */
23591    case 630: value = 629; break;	/* ubfiz --> ubfm.  */
23592    case 665: value = 664; break;	/* cset --> cinc.  */
23593    case 664: value = 663; break;	/* cinc --> csinc.  */
23594    case 668: value = 667; break;	/* csetm --> cinv.  */
23595    case 667: value = 666; break;	/* cinv --> csinv.  */
23596    case 670: value = 669; break;	/* cneg --> csneg.  */
23597    case 688: value = 689; break;	/* rev --> rev64.  */
23598    case 714: value = 713; break;	/* lsl --> lslv.  */
23599    case 716: value = 715; break;	/* lsr --> lsrv.  */
23600    case 718: value = 717; break;	/* asr --> asrv.  */
23601    case 720: value = 719; break;	/* ror --> rorv.  */
23602    case 723: value = 722; break;	/* cmpp --> subps.  */
23603    case 736: value = 735; break;	/* mul --> madd.  */
23604    case 738: value = 737; break;	/* mneg --> msub.  */
23605    case 740: value = 739; break;	/* smull --> smaddl.  */
23606    case 742: value = 741; break;	/* smnegl --> smsubl.  */
23607    case 745: value = 744; break;	/* umull --> umaddl.  */
23608    case 747: value = 746; break;	/* umnegl --> umsubl.  */
23609    case 758: value = 757; break;	/* ror --> extr.  */
23610    case 991: value = 990; break;	/* bic --> and.  */
23611    case 993: value = 992; break;	/* mov --> orr.  */
23612    case 996: value = 995; break;	/* tst --> ands.  */
23613    case 1001: value = 1000; break;	/* uxtw --> mov.  */
23614    case 1000: value = 999; break;	/* mov --> orr.  */
23615    case 1003: value = 1002; break;	/* mvn --> orn.  */
23616    case 1007: value = 1006; break;	/* tst --> ands.  */
23617    case 1133: value = 1037; break;	/* staddb --> ldaddb.  */
23618    case 1134: value = 1038; break;	/* staddh --> ldaddh.  */
23619    case 1135: value = 1039; break;	/* stadd --> ldadd.  */
23620    case 1136: value = 1041; break;	/* staddlb --> ldaddlb.  */
23621    case 1137: value = 1044; break;	/* staddlh --> ldaddlh.  */
23622    case 1138: value = 1047; break;	/* staddl --> ldaddl.  */
23623    case 1139: value = 1049; break;	/* stclrb --> ldclrb.  */
23624    case 1140: value = 1050; break;	/* stclrh --> ldclrh.  */
23625    case 1141: value = 1051; break;	/* stclr --> ldclr.  */
23626    case 1142: value = 1053; break;	/* stclrlb --> ldclrlb.  */
23627    case 1143: value = 1056; break;	/* stclrlh --> ldclrlh.  */
23628    case 1144: value = 1059; break;	/* stclrl --> ldclrl.  */
23629    case 1145: value = 1061; break;	/* steorb --> ldeorb.  */
23630    case 1146: value = 1062; break;	/* steorh --> ldeorh.  */
23631    case 1147: value = 1063; break;	/* steor --> ldeor.  */
23632    case 1148: value = 1065; break;	/* steorlb --> ldeorlb.  */
23633    case 1149: value = 1068; break;	/* steorlh --> ldeorlh.  */
23634    case 1150: value = 1071; break;	/* steorl --> ldeorl.  */
23635    case 1151: value = 1073; break;	/* stsetb --> ldsetb.  */
23636    case 1152: value = 1074; break;	/* stseth --> ldseth.  */
23637    case 1153: value = 1075; break;	/* stset --> ldset.  */
23638    case 1154: value = 1077; break;	/* stsetlb --> ldsetlb.  */
23639    case 1155: value = 1080; break;	/* stsetlh --> ldsetlh.  */
23640    case 1156: value = 1083; break;	/* stsetl --> ldsetl.  */
23641    case 1157: value = 1085; break;	/* stsmaxb --> ldsmaxb.  */
23642    case 1158: value = 1086; break;	/* stsmaxh --> ldsmaxh.  */
23643    case 1159: value = 1087; break;	/* stsmax --> ldsmax.  */
23644    case 1160: value = 1089; break;	/* stsmaxlb --> ldsmaxlb.  */
23645    case 1161: value = 1092; break;	/* stsmaxlh --> ldsmaxlh.  */
23646    case 1162: value = 1095; break;	/* stsmaxl --> ldsmaxl.  */
23647    case 1163: value = 1097; break;	/* stsminb --> ldsminb.  */
23648    case 1164: value = 1098; break;	/* stsminh --> ldsminh.  */
23649    case 1165: value = 1099; break;	/* stsmin --> ldsmin.  */
23650    case 1166: value = 1101; break;	/* stsminlb --> ldsminlb.  */
23651    case 1167: value = 1104; break;	/* stsminlh --> ldsminlh.  */
23652    case 1168: value = 1107; break;	/* stsminl --> ldsminl.  */
23653    case 1169: value = 1109; break;	/* stumaxb --> ldumaxb.  */
23654    case 1170: value = 1110; break;	/* stumaxh --> ldumaxh.  */
23655    case 1171: value = 1111; break;	/* stumax --> ldumax.  */
23656    case 1172: value = 1113; break;	/* stumaxlb --> ldumaxlb.  */
23657    case 1173: value = 1116; break;	/* stumaxlh --> ldumaxlh.  */
23658    case 1174: value = 1119; break;	/* stumaxl --> ldumaxl.  */
23659    case 1175: value = 1121; break;	/* stuminb --> lduminb.  */
23660    case 1176: value = 1122; break;	/* stuminh --> lduminh.  */
23661    case 1177: value = 1123; break;	/* stumin --> ldumin.  */
23662    case 1178: value = 1125; break;	/* stuminlb --> lduminlb.  */
23663    case 1179: value = 1128; break;	/* stuminlh --> lduminlh.  */
23664    case 1180: value = 1131; break;	/* stuminl --> lduminl.  */
23665    case 1182: value = 1181; break;	/* mov --> movn.  */
23666    case 1184: value = 1183; break;	/* mov --> movz.  */
23667    case 1235: value = 1234; break;	/* autibsp --> autibz.  */
23668    case 1234: value = 1233; break;	/* autibz --> autiasp.  */
23669    case 1233: value = 1232; break;	/* autiasp --> autiaz.  */
23670    case 1232: value = 1231; break;	/* autiaz --> pacibsp.  */
23671    case 1231: value = 1230; break;	/* pacibsp --> pacibz.  */
23672    case 1230: value = 1229; break;	/* pacibz --> paciasp.  */
23673    case 1229: value = 1228; break;	/* paciasp --> paciaz.  */
23674    case 1228: value = 1208; break;	/* paciaz --> psb.  */
23675    case 1208: value = 1207; break;	/* psb --> esb.  */
23676    case 1207: value = 1206; break;	/* esb --> autib1716.  */
23677    case 1206: value = 1205; break;	/* autib1716 --> autia1716.  */
23678    case 1205: value = 1204; break;	/* autia1716 --> pacib1716.  */
23679    case 1204: value = 1203; break;	/* pacib1716 --> pacia1716.  */
23680    case 1203: value = 1202; break;	/* pacia1716 --> xpaclri.  */
23681    case 1202: value = 1201; break;	/* xpaclri --> sevl.  */
23682    case 1201: value = 1200; break;	/* sevl --> sev.  */
23683    case 1200: value = 1199; break;	/* sev --> wfi.  */
23684    case 1199: value = 1198; break;	/* wfi --> wfe.  */
23685    case 1198: value = 1197; break;	/* wfe --> yield.  */
23686    case 1197: value = 1196; break;	/* yield --> bti.  */
23687    case 1196: value = 1195; break;	/* bti --> csdb.  */
23688    case 1195: value = 1194; break;	/* csdb --> nop.  */
23689    case 1194: value = 1193; break;	/* nop --> hint.  */
23690    case 1212: value = 1211; break;	/* pssbb --> ssbb.  */
23691    case 1211: value = 1210; break;	/* ssbb --> dsb.  */
23692    case 1223: value = 1222; break;	/* cpp --> dvp.  */
23693    case 1222: value = 1221; break;	/* dvp --> cfp.  */
23694    case 1221: value = 1220; break;	/* cfp --> tlbi.  */
23695    case 1220: value = 1219; break;	/* tlbi --> ic.  */
23696    case 1219: value = 1218; break;	/* ic --> dc.  */
23697    case 1218: value = 1217; break;	/* dc --> at.  */
23698    case 1217: value = 1216; break;	/* at --> sys.  */
23699    case 2033: value = 1283; break;	/* bic --> and.  */
23700    case 1266: value = 1285; break;	/* mov --> and.  */
23701    case 1270: value = 1286; break;	/* movs --> ands.  */
23702    case 2034: value = 1321; break;	/* cmple --> cmpge.  */
23703    case 2037: value = 1324; break;	/* cmplt --> cmpgt.  */
23704    case 2035: value = 1326; break;	/* cmplo --> cmphi.  */
23705    case 2036: value = 1329; break;	/* cmpls --> cmphs.  */
23706    case 1263: value = 1351; break;	/* mov --> cpy.  */
23707    case 1265: value = 1352; break;	/* mov --> cpy.  */
23708    case 2044: value = 1268; break;	/* fmov --> mov.  */
23709    case 1268: value = 1353; break;	/* mov --> cpy.  */
23710    case 1258: value = 1365; break;	/* mov --> dup.  */
23711    case 1260: value = 1257; break;	/* mov --> mov.  */
23712    case 1257: value = 1366; break;	/* mov --> dup.  */
23713    case 2043: value = 1262; break;	/* fmov --> mov.  */
23714    case 1262: value = 1367; break;	/* mov --> dup.  */
23715    case 1261: value = 1368; break;	/* mov --> dupm.  */
23716    case 2038: value = 1370; break;	/* eon --> eor.  */
23717    case 1271: value = 1372; break;	/* not --> eor.  */
23718    case 1272: value = 1373; break;	/* nots --> eors.  */
23719    case 2039: value = 1378; break;	/* facle --> facge.  */
23720    case 2040: value = 1379; break;	/* faclt --> facgt.  */
23721    case 2041: value = 1392; break;	/* fcmle --> fcmge.  */
23722    case 2042: value = 1394; break;	/* fcmlt --> fcmgt.  */
23723    case 1255: value = 1400; break;	/* fmov --> fcpy.  */
23724    case 1254: value = 1423; break;	/* fmov --> fdup.  */
23725    case 1256: value = 1754; break;	/* mov --> orr.  */
23726    case 2045: value = 1755; break;	/* orn --> orr.  */
23727    case 1259: value = 1757; break;	/* mov --> orr.  */
23728    case 1269: value = 1758; break;	/* movs --> orrs.  */
23729    case 1264: value = 1820; break;	/* mov --> sel.  */
23730    case 1267: value = 1821; break;	/* mov --> sel.  */
23731    default: return NULL;
23732    }
23733
23734  return aarch64_opcode_table + value;
23735}
23736
23737bfd_boolean
23738aarch64_extract_operand (const aarch64_operand *self,
23739			   aarch64_opnd_info *info,
23740			   aarch64_insn code, const aarch64_inst *inst,
23741			   aarch64_operand_error *errors)
23742{
23743  /* Use the index as the key.  */
23744  int key = self - aarch64_operands;
23745  switch (key)
23746    {
23747    case 1:
23748    case 2:
23749    case 3:
23750    case 4:
23751    case 5:
23752    case 6:
23753    case 7:
23754    case 8:
23755    case 10:
23756    case 11:
23757    case 12:
23758    case 16:
23759    case 17:
23760    case 18:
23761    case 19:
23762    case 21:
23763    case 22:
23764    case 23:
23765    case 24:
23766    case 25:
23767    case 26:
23768    case 27:
23769    case 28:
23770    case 29:
23771    case 30:
23772    case 163:
23773    case 164:
23774    case 165:
23775    case 166:
23776    case 167:
23777    case 168:
23778    case 169:
23779    case 170:
23780    case 171:
23781    case 172:
23782    case 187:
23783    case 188:
23784    case 189:
23785    case 190:
23786    case 191:
23787    case 192:
23788    case 193:
23789    case 194:
23790    case 195:
23791    case 201:
23792    case 204:
23793      return aarch64_ext_regno (self, info, code, inst, errors);
23794    case 9:
23795      return aarch64_ext_regrt_sysins (self, info, code, inst, errors);
23796    case 13:
23797      return aarch64_ext_regno_pair (self, info, code, inst, errors);
23798    case 14:
23799      return aarch64_ext_reg_extended (self, info, code, inst, errors);
23800    case 15:
23801      return aarch64_ext_reg_shifted (self, info, code, inst, errors);
23802    case 20:
23803      return aarch64_ext_ft (self, info, code, inst, errors);
23804    case 31:
23805    case 32:
23806    case 33:
23807    case 34:
23808    case 207:
23809      return aarch64_ext_reglane (self, info, code, inst, errors);
23810    case 35:
23811      return aarch64_ext_reglist (self, info, code, inst, errors);
23812    case 36:
23813      return aarch64_ext_ldst_reglist (self, info, code, inst, errors);
23814    case 37:
23815      return aarch64_ext_ldst_reglist_r (self, info, code, inst, errors);
23816    case 38:
23817      return aarch64_ext_ldst_elemlist (self, info, code, inst, errors);
23818    case 39:
23819    case 40:
23820    case 41:
23821    case 42:
23822    case 52:
23823    case 53:
23824    case 54:
23825    case 55:
23826    case 56:
23827    case 57:
23828    case 58:
23829    case 59:
23830    case 60:
23831    case 61:
23832    case 62:
23833    case 63:
23834    case 64:
23835    case 65:
23836    case 66:
23837    case 67:
23838    case 78:
23839    case 79:
23840    case 80:
23841    case 81:
23842    case 82:
23843    case 160:
23844    case 162:
23845    case 179:
23846    case 180:
23847    case 181:
23848    case 182:
23849    case 183:
23850    case 184:
23851    case 185:
23852    case 186:
23853    case 206:
23854      return aarch64_ext_imm (self, info, code, inst, errors);
23855    case 43:
23856    case 44:
23857      return aarch64_ext_advsimd_imm_shift (self, info, code, inst, errors);
23858    case 45:
23859    case 46:
23860    case 47:
23861      return aarch64_ext_advsimd_imm_modified (self, info, code, inst, errors);
23862    case 48:
23863      return aarch64_ext_shll_imm (self, info, code, inst, errors);
23864    case 51:
23865    case 150:
23866      return aarch64_ext_fpimm (self, info, code, inst, errors);
23867    case 68:
23868    case 158:
23869      return aarch64_ext_limm (self, info, code, inst, errors);
23870    case 69:
23871      return aarch64_ext_aimm (self, info, code, inst, errors);
23872    case 70:
23873      return aarch64_ext_imm_half (self, info, code, inst, errors);
23874    case 71:
23875      return aarch64_ext_fbits (self, info, code, inst, errors);
23876    case 73:
23877    case 74:
23878    case 155:
23879      return aarch64_ext_imm_rotate2 (self, info, code, inst, errors);
23880    case 75:
23881    case 154:
23882    case 156:
23883      return aarch64_ext_imm_rotate1 (self, info, code, inst, errors);
23884    case 76:
23885    case 77:
23886      return aarch64_ext_cond (self, info, code, inst, errors);
23887    case 83:
23888    case 92:
23889      return aarch64_ext_addr_simple (self, info, code, inst, errors);
23890    case 84:
23891      return aarch64_ext_addr_regoff (self, info, code, inst, errors);
23892    case 85:
23893    case 86:
23894    case 87:
23895    case 89:
23896    case 91:
23897      return aarch64_ext_addr_simm (self, info, code, inst, errors);
23898    case 88:
23899      return aarch64_ext_addr_simm10 (self, info, code, inst, errors);
23900    case 90:
23901      return aarch64_ext_addr_uimm12 (self, info, code, inst, errors);
23902    case 93:
23903      return aarch64_ext_addr_offset (self, info, code, inst, errors);
23904    case 94:
23905      return aarch64_ext_simd_addr_post (self, info, code, inst, errors);
23906    case 95:
23907      return aarch64_ext_sysreg (self, info, code, inst, errors);
23908    case 96:
23909      return aarch64_ext_pstatefield (self, info, code, inst, errors);
23910    case 97:
23911    case 98:
23912    case 99:
23913    case 100:
23914    case 101:
23915      return aarch64_ext_sysins_op (self, info, code, inst, errors);
23916    case 102:
23917    case 103:
23918      return aarch64_ext_barrier (self, info, code, inst, errors);
23919    case 104:
23920      return aarch64_ext_prfop (self, info, code, inst, errors);
23921    case 105:
23922    case 106:
23923      return aarch64_ext_hint (self, info, code, inst, errors);
23924    case 107:
23925    case 108:
23926      return aarch64_ext_sve_addr_ri_s4 (self, info, code, inst, errors);
23927    case 109:
23928    case 110:
23929    case 111:
23930    case 112:
23931      return aarch64_ext_sve_addr_ri_s4xvl (self, info, code, inst, errors);
23932    case 113:
23933      return aarch64_ext_sve_addr_ri_s6xvl (self, info, code, inst, errors);
23934    case 114:
23935      return aarch64_ext_sve_addr_ri_s9xvl (self, info, code, inst, errors);
23936    case 115:
23937    case 116:
23938    case 117:
23939    case 118:
23940      return aarch64_ext_sve_addr_ri_u6 (self, info, code, inst, errors);
23941    case 119:
23942    case 120:
23943    case 121:
23944    case 122:
23945    case 123:
23946    case 124:
23947    case 125:
23948    case 126:
23949    case 127:
23950    case 128:
23951    case 129:
23952    case 130:
23953    case 131:
23954    case 132:
23955      return aarch64_ext_sve_addr_rr_lsl (self, info, code, inst, errors);
23956    case 133:
23957    case 134:
23958    case 135:
23959    case 136:
23960    case 137:
23961    case 138:
23962    case 139:
23963    case 140:
23964      return aarch64_ext_sve_addr_rz_xtw (self, info, code, inst, errors);
23965    case 141:
23966    case 142:
23967    case 143:
23968    case 144:
23969      return aarch64_ext_sve_addr_zi_u5 (self, info, code, inst, errors);
23970    case 145:
23971      return aarch64_ext_sve_addr_zz_lsl (self, info, code, inst, errors);
23972    case 146:
23973      return aarch64_ext_sve_addr_zz_sxtw (self, info, code, inst, errors);
23974    case 147:
23975      return aarch64_ext_sve_addr_zz_uxtw (self, info, code, inst, errors);
23976    case 148:
23977      return aarch64_ext_sve_aimm (self, info, code, inst, errors);
23978    case 149:
23979      return aarch64_ext_sve_asimm (self, info, code, inst, errors);
23980    case 151:
23981      return aarch64_ext_sve_float_half_one (self, info, code, inst, errors);
23982    case 152:
23983      return aarch64_ext_sve_float_half_two (self, info, code, inst, errors);
23984    case 153:
23985      return aarch64_ext_sve_float_zero_one (self, info, code, inst, errors);
23986    case 157:
23987      return aarch64_ext_inv_limm (self, info, code, inst, errors);
23988    case 159:
23989      return aarch64_ext_sve_limm_mov (self, info, code, inst, errors);
23990    case 161:
23991      return aarch64_ext_sve_scale (self, info, code, inst, errors);
23992    case 173:
23993    case 174:
23994    case 175:
23995      return aarch64_ext_sve_shlimm (self, info, code, inst, errors);
23996    case 176:
23997    case 177:
23998    case 178:
23999      return aarch64_ext_sve_shrimm (self, info, code, inst, errors);
24000    case 196:
24001    case 197:
24002    case 198:
24003    case 199:
24004    case 200:
24005      return aarch64_ext_sve_quad_index (self, info, code, inst, errors);
24006    case 202:
24007      return aarch64_ext_sve_index (self, info, code, inst, errors);
24008    case 203:
24009    case 205:
24010      return aarch64_ext_sve_reglist (self, info, code, inst, errors);
24011    default: assert (0); abort ();
24012    }
24013}
24014