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