aarch64-dis-2.c revision 1.5
1/* This file is automatically generated by aarch64-gen.  Do not edit!  */
2/* Copyright (C) 2012-2015 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                         xxxxxxxxxxxxxxxxxxxxxxxx0000xxx0
42                         adr.  */
43                      return 955;
44                    }
45                  else
46                    {
47                      /* 33222222222211111111110000000000
48                         10987654321098765432109876543210
49                         xxxxxxxxxxxxxxxxxxxxxxxx0000xxx1
50                         adrp.  */
51                      return 956;
52                    }
53                }
54              else
55                {
56                  if (((word >> 29) & 0x1) == 0)
57                    {
58                      if (((word >> 30) & 0x1) == 0)
59                        {
60                          /* 33222222222211111111110000000000
61                             10987654321098765432109876543210
62                             xxxxxxxxxxxxxxxxxxxxxxxx1000x00x
63                             add.  */
64                          return 12;
65                        }
66                      else
67                        {
68                          /* 33222222222211111111110000000000
69                             10987654321098765432109876543210
70                             xxxxxxxxxxxxxxxxxxxxxxxx1000x01x
71                             sub.  */
72                          return 16;
73                        }
74                    }
75                  else
76                    {
77                      if (((word >> 30) & 0x1) == 0)
78                        {
79                          /* 33222222222211111111110000000000
80                             10987654321098765432109876543210
81                             xxxxxxxxxxxxxxxxxxxxxxxx1000x10x
82                             adds.  */
83                          return 14;
84                        }
85                      else
86                        {
87                          /* 33222222222211111111110000000000
88                             10987654321098765432109876543210
89                             xxxxxxxxxxxxxxxxxxxxxxxx1000x11x
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                                                 xxxxxxxxxxxxxxx0xxxxx000x0010000
117                                                 stxrb.  */
118                                              return 713;
119                                            }
120                                          else
121                                            {
122                                              /* 33222222222211111111110000000000
123                                                 10987654321098765432109876543210
124                                                 xxxxxxxxxxxxxxx0xxxxx000x0010010
125                                                 stxrh.  */
126                                              return 719;
127                                            }
128                                        }
129                                      else
130                                        {
131                                          /* 33222222222211111111110000000000
132                                             10987654321098765432109876543210
133                                             xxxxxxxxxxxxxxx0xxxxx000x00100x1
134                                             stxr.  */
135                                          return 725;
136                                        }
137                                    }
138                                  else
139                                    {
140                                      if (((word >> 31) & 0x1) == 0)
141                                        {
142                                          /* 33222222222211111111110000000000
143                                             10987654321098765432109876543210
144                                             xxxxxxxxxxxxxxx0xxxxx100x00100x0
145                                             casp.  */
146                                          return 790;
147                                        }
148                                      else
149                                        {
150                                          /* 33222222222211111111110000000000
151                                             10987654321098765432109876543210
152                                             xxxxxxxxxxxxxxx0xxxxx100x00100x1
153                                             stxp.  */
154                                          return 727;
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                                                 xxxxxxxxxxxxxxx1xxxxx000x0010000
169                                                 stlxrb.  */
170                                              return 714;
171                                            }
172                                          else
173                                            {
174                                              /* 33222222222211111111110000000000
175                                                 10987654321098765432109876543210
176                                                 xxxxxxxxxxxxxxx1xxxxx000x0010010
177                                                 stlxrh.  */
178                                              return 720;
179                                            }
180                                        }
181                                      else
182                                        {
183                                          /* 33222222222211111111110000000000
184                                             10987654321098765432109876543210
185                                             xxxxxxxxxxxxxxx1xxxxx000x00100x1
186                                             stlxr.  */
187                                          return 726;
188                                        }
189                                    }
190                                  else
191                                    {
192                                      if (((word >> 31) & 0x1) == 0)
193                                        {
194                                          /* 33222222222211111111110000000000
195                                             10987654321098765432109876543210
196                                             xxxxxxxxxxxxxxx1xxxxx100x00100x0
197                                             caspl.  */
198                                          return 792;
199                                        }
200                                      else
201                                        {
202                                          /* 33222222222211111111110000000000
203                                             10987654321098765432109876543210
204                                             xxxxxxxxxxxxxxx1xxxxx100x00100x1
205                                             stlxp.  */
206                                          return 728;
207                                        }
208                                    }
209                                }
210                            }
211                          else
212                            {
213                              /* 33222222222211111111110000000000
214                                 10987654321098765432109876543210
215                                 xxxxxxxxxxxxxxxxxxxxxx00x00101xx
216                                 stnp.  */
217                              return 741;
218                            }
219                        }
220                      else
221                        {
222                          if (((word >> 29) & 0x1) == 0)
223                            {
224                              if (((word >> 15) & 0x1) == 0)
225                                {
226                                  if (((word >> 21) & 0x1) == 0)
227                                    {
228                                      if (((word >> 31) & 0x1) == 0)
229                                        {
230                                          /* 33222222222211111111110000000000
231                                             10987654321098765432109876543210
232                                             xxxxxxxxxxxxxxx0xxxxx001x00100x0
233                                             stllrb.  */
234                                          return 739;
235                                        }
236                                      else
237                                        {
238                                          /* 33222222222211111111110000000000
239                                             10987654321098765432109876543210
240                                             xxxxxxxxxxxxxxx0xxxxx001x00100x1
241                                             stllr.  */
242                                          return 738;
243                                        }
244                                    }
245                                  else
246                                    {
247                                      if (((word >> 31) & 0x1) == 0)
248                                        {
249                                          if (((word >> 30) & 0x1) == 0)
250                                            {
251                                              /* 33222222222211111111110000000000
252                                                 10987654321098765432109876543210
253                                                 xxxxxxxxxxxxxxx0xxxxx101x0010000
254                                                 casb.  */
255                                              return 778;
256                                            }
257                                          else
258                                            {
259                                              /* 33222222222211111111110000000000
260                                                 10987654321098765432109876543210
261                                                 xxxxxxxxxxxxxxx0xxxxx101x0010010
262                                                 cash.  */
263                                              return 779;
264                                            }
265                                        }
266                                      else
267                                        {
268                                          /* 33222222222211111111110000000000
269                                             10987654321098765432109876543210
270                                             xxxxxxxxxxxxxxx0xxxxx101x00100x1
271                                             cas.  */
272                                          return 780;
273                                        }
274                                    }
275                                }
276                              else
277                                {
278                                  if (((word >> 21) & 0x1) == 0)
279                                    {
280                                      if (((word >> 31) & 0x1) == 0)
281                                        {
282                                          if (((word >> 30) & 0x1) == 0)
283                                            {
284                                              /* 33222222222211111111110000000000
285                                                 10987654321098765432109876543210
286                                                 xxxxxxxxxxxxxxx1xxxxx001x0010000
287                                                 stlrb.  */
288                                              return 717;
289                                            }
290                                          else
291                                            {
292                                              /* 33222222222211111111110000000000
293                                                 10987654321098765432109876543210
294                                                 xxxxxxxxxxxxxxx1xxxxx001x0010010
295                                                 stlrh.  */
296                                              return 723;
297                                            }
298                                        }
299                                      else
300                                        {
301                                          /* 33222222222211111111110000000000
302                                             10987654321098765432109876543210
303                                             xxxxxxxxxxxxxxx1xxxxx001x00100x1
304                                             stlr.  */
305                                          return 733;
306                                        }
307                                    }
308                                  else
309                                    {
310                                      if (((word >> 31) & 0x1) == 0)
311                                        {
312                                          if (((word >> 30) & 0x1) == 0)
313                                            {
314                                              /* 33222222222211111111110000000000
315                                                 10987654321098765432109876543210
316                                                 xxxxxxxxxxxxxxx1xxxxx101x0010000
317                                                 caslb.  */
318                                              return 782;
319                                            }
320                                          else
321                                            {
322                                              /* 33222222222211111111110000000000
323                                                 10987654321098765432109876543210
324                                                 xxxxxxxxxxxxxxx1xxxxx101x0010010
325                                                 caslh.  */
326                                              return 785;
327                                            }
328                                        }
329                                      else
330                                        {
331                                          /* 33222222222211111111110000000000
332                                             10987654321098765432109876543210
333                                             xxxxxxxxxxxxxxx1xxxxx101x00100x1
334                                             casl.  */
335                                          return 788;
336                                        }
337                                    }
338                                }
339                            }
340                          else
341                            {
342                              /* 33222222222211111111110000000000
343                                 10987654321098765432109876543210
344                                 xxxxxxxxxxxxxxxxxxxxxx01x00101xx
345                                 stp.  */
346                              return 750;
347                            }
348                        }
349                    }
350                  else
351                    {
352                      if (((word >> 23) & 0x1) == 0)
353                        {
354                          if (((word >> 29) & 0x1) == 0)
355                            {
356                              if (((word >> 15) & 0x1) == 0)
357                                {
358                                  if (((word >> 21) & 0x1) == 0)
359                                    {
360                                      if (((word >> 31) & 0x1) == 0)
361                                        {
362                                          if (((word >> 30) & 0x1) == 0)
363                                            {
364                                              /* 33222222222211111111110000000000
365                                                 10987654321098765432109876543210
366                                                 xxxxxxxxxxxxxxx0xxxxx010x0010000
367                                                 ldxrb.  */
368                                              return 715;
369                                            }
370                                          else
371                                            {
372                                              /* 33222222222211111111110000000000
373                                                 10987654321098765432109876543210
374                                                 xxxxxxxxxxxxxxx0xxxxx010x0010010
375                                                 ldxrh.  */
376                                              return 721;
377                                            }
378                                        }
379                                      else
380                                        {
381                                          /* 33222222222211111111110000000000
382                                             10987654321098765432109876543210
383                                             xxxxxxxxxxxxxxx0xxxxx010x00100x1
384                                             ldxr.  */
385                                          return 729;
386                                        }
387                                    }
388                                  else
389                                    {
390                                      if (((word >> 31) & 0x1) == 0)
391                                        {
392                                          /* 33222222222211111111110000000000
393                                             10987654321098765432109876543210
394                                             xxxxxxxxxxxxxxx0xxxxx110x00100x0
395                                             caspa.  */
396                                          return 791;
397                                        }
398                                      else
399                                        {
400                                          /* 33222222222211111111110000000000
401                                             10987654321098765432109876543210
402                                             xxxxxxxxxxxxxxx0xxxxx110x00100x1
403                                             ldxp.  */
404                                          return 731;
405                                        }
406                                    }
407                                }
408                              else
409                                {
410                                  if (((word >> 21) & 0x1) == 0)
411                                    {
412                                      if (((word >> 31) & 0x1) == 0)
413                                        {
414                                          if (((word >> 30) & 0x1) == 0)
415                                            {
416                                              /* 33222222222211111111110000000000
417                                                 10987654321098765432109876543210
418                                                 xxxxxxxxxxxxxxx1xxxxx010x0010000
419                                                 ldaxrb.  */
420                                              return 716;
421                                            }
422                                          else
423                                            {
424                                              /* 33222222222211111111110000000000
425                                                 10987654321098765432109876543210
426                                                 xxxxxxxxxxxxxxx1xxxxx010x0010010
427                                                 ldaxrh.  */
428                                              return 722;
429                                            }
430                                        }
431                                      else
432                                        {
433                                          /* 33222222222211111111110000000000
434                                             10987654321098765432109876543210
435                                             xxxxxxxxxxxxxxx1xxxxx010x00100x1
436                                             ldaxr.  */
437                                          return 730;
438                                        }
439                                    }
440                                  else
441                                    {
442                                      if (((word >> 31) & 0x1) == 0)
443                                        {
444                                          /* 33222222222211111111110000000000
445                                             10987654321098765432109876543210
446                                             xxxxxxxxxxxxxxx1xxxxx110x00100x0
447                                             caspal.  */
448                                          return 793;
449                                        }
450                                      else
451                                        {
452                                          /* 33222222222211111111110000000000
453                                             10987654321098765432109876543210
454                                             xxxxxxxxxxxxxxx1xxxxx110x00100x1
455                                             ldaxp.  */
456                                          return 732;
457                                        }
458                                    }
459                                }
460                            }
461                          else
462                            {
463                              if (((word >> 30) & 0x1) == 0)
464                                {
465                                  /* 33222222222211111111110000000000
466                                     10987654321098765432109876543210
467                                     xxxxxxxxxxxxxxxxxxxxxx10x001010x
468                                     ldnp.  */
469                                  return 742;
470                                }
471                              else
472                                {
473                                  /* 33222222222211111111110000000000
474                                     10987654321098765432109876543210
475                                     xxxxxxxxxxxxxxxxxxxxxx10x001011x
476                                     ldpsw.  */
477                                  return 749;
478                                }
479                            }
480                        }
481                      else
482                        {
483                          if (((word >> 29) & 0x1) == 0)
484                            {
485                              if (((word >> 15) & 0x1) == 0)
486                                {
487                                  if (((word >> 21) & 0x1) == 0)
488                                    {
489                                      if (((word >> 31) & 0x1) == 0)
490                                        {
491                                          if (((word >> 30) & 0x1) == 0)
492                                            {
493                                              /* 33222222222211111111110000000000
494                                                 10987654321098765432109876543210
495                                                 xxxxxxxxxxxxxxx0xxxxx011x0010000
496                                                 ldlarb.  */
497                                              return 736;
498                                            }
499                                          else
500                                            {
501                                              /* 33222222222211111111110000000000
502                                                 10987654321098765432109876543210
503                                                 xxxxxxxxxxxxxxx0xxxxx011x0010010
504                                                 ldlarh.  */
505                                              return 737;
506                                            }
507                                        }
508                                      else
509                                        {
510                                          /* 33222222222211111111110000000000
511                                             10987654321098765432109876543210
512                                             xxxxxxxxxxxxxxx0xxxxx011x00100x1
513                                             ldlar.  */
514                                          return 735;
515                                        }
516                                    }
517                                  else
518                                    {
519                                      if (((word >> 31) & 0x1) == 0)
520                                        {
521                                          if (((word >> 30) & 0x1) == 0)
522                                            {
523                                              /* 33222222222211111111110000000000
524                                                 10987654321098765432109876543210
525                                                 xxxxxxxxxxxxxxx0xxxxx111x0010000
526                                                 casab.  */
527                                              return 781;
528                                            }
529                                          else
530                                            {
531                                              /* 33222222222211111111110000000000
532                                                 10987654321098765432109876543210
533                                                 xxxxxxxxxxxxxxx0xxxxx111x0010010
534                                                 casah.  */
535                                              return 784;
536                                            }
537                                        }
538                                      else
539                                        {
540                                          /* 33222222222211111111110000000000
541                                             10987654321098765432109876543210
542                                             xxxxxxxxxxxxxxx0xxxxx111x00100x1
543                                             casa.  */
544                                          return 787;
545                                        }
546                                    }
547                                }
548                              else
549                                {
550                                  if (((word >> 21) & 0x1) == 0)
551                                    {
552                                      if (((word >> 31) & 0x1) == 0)
553                                        {
554                                          if (((word >> 30) & 0x1) == 0)
555                                            {
556                                              /* 33222222222211111111110000000000
557                                                 10987654321098765432109876543210
558                                                 xxxxxxxxxxxxxxx1xxxxx011x0010000
559                                                 ldarb.  */
560                                              return 718;
561                                            }
562                                          else
563                                            {
564                                              /* 33222222222211111111110000000000
565                                                 10987654321098765432109876543210
566                                                 xxxxxxxxxxxxxxx1xxxxx011x0010010
567                                                 ldarh.  */
568                                              return 724;
569                                            }
570                                        }
571                                      else
572                                        {
573                                          /* 33222222222211111111110000000000
574                                             10987654321098765432109876543210
575                                             xxxxxxxxxxxxxxx1xxxxx011x00100x1
576                                             ldar.  */
577                                          return 734;
578                                        }
579                                    }
580                                  else
581                                    {
582                                      if (((word >> 31) & 0x1) == 0)
583                                        {
584                                          if (((word >> 30) & 0x1) == 0)
585                                            {
586                                              /* 33222222222211111111110000000000
587                                                 10987654321098765432109876543210
588                                                 xxxxxxxxxxxxxxx1xxxxx111x0010000
589                                                 casalb.  */
590                                              return 783;
591                                            }
592                                          else
593                                            {
594                                              /* 33222222222211111111110000000000
595                                                 10987654321098765432109876543210
596                                                 xxxxxxxxxxxxxxx1xxxxx111x0010010
597                                                 casalh.  */
598                                              return 786;
599                                            }
600                                        }
601                                      else
602                                        {
603                                          /* 33222222222211111111110000000000
604                                             10987654321098765432109876543210
605                                             xxxxxxxxxxxxxxx1xxxxx111x00100x1
606                                             casal.  */
607                                          return 789;
608                                        }
609                                    }
610                                }
611                            }
612                          else
613                            {
614                              if (((word >> 30) & 0x1) == 0)
615                                {
616                                  /* 33222222222211111111110000000000
617                                     10987654321098765432109876543210
618                                     xxxxxxxxxxxxxxxxxxxxxx11x001010x
619                                     ldp.  */
620                                  return 751;
621                                }
622                              else
623                                {
624                                  /* 33222222222211111111110000000000
625                                     10987654321098765432109876543210
626                                     xxxxxxxxxxxxxxxxxxxxxx11x001011x
627                                     ldpsw.  */
628                                  return 754;
629                                }
630                            }
631                        }
632                    }
633                }
634              else
635                {
636                  if (((word >> 24) & 0x1) == 0)
637                    {
638                      if (((word >> 29) & 0x1) == 0)
639                        {
640                          if (((word >> 31) & 0x1) == 0)
641                            {
642                              /* 33222222222211111111110000000000
643                                 10987654321098765432109876543210
644                                 xxxxxxxxxxxxxxxxxxxxxxxx000110x0
645                                 ldr.  */
646                              return 755;
647                            }
648                          else
649                            {
650                              if (((word >> 30) & 0x1) == 0)
651                                {
652                                  /* 33222222222211111111110000000000
653                                     10987654321098765432109876543210
654                                     xxxxxxxxxxxxxxxxxxxxxxxx00011001
655                                     ldrsw.  */
656                                  return 757;
657                                }
658                              else
659                                {
660                                  /* 33222222222211111111110000000000
661                                     10987654321098765432109876543210
662                                     xxxxxxxxxxxxxxxxxxxxxxxx00011011
663                                     prfm.  */
664                                  return 758;
665                                }
666                            }
667                        }
668                      else
669                        {
670                          if (((word >> 10) & 0x1) == 0)
671                            {
672                              if (((word >> 11) & 0x1) == 0)
673                                {
674                                  if (((word >> 21) & 0x1) == 0)
675                                    {
676                                      if (((word >> 23) & 0x1) == 0)
677                                        {
678                                          if (((word >> 22) & 0x1) == 0)
679                                            {
680                                              if (((word >> 31) & 0x1) == 0)
681                                                {
682                                                  if (((word >> 30) & 0x1) == 0)
683                                                    {
684                                                      /* 33222222222211111111110000000000
685                                                         10987654321098765432109876543210
686                                                         xxxxxxxxxx00xxxxxxxxx00000011100
687                                                         sturb.  */
688                                                      return 701;
689                                                    }
690                                                  else
691                                                    {
692                                                      /* 33222222222211111111110000000000
693                                                         10987654321098765432109876543210
694                                                         xxxxxxxxxx00xxxxxxxxx00000011110
695                                                         sturh.  */
696                                                      return 706;
697                                                    }
698                                                }
699                                              else
700                                                {
701                                                  /* 33222222222211111111110000000000
702                                                     10987654321098765432109876543210
703                                                     xxxxxxxxxx00xxxxxxxxx000000111x1
704                                                     stur.  */
705                                                  return 709;
706                                                }
707                                            }
708                                          else
709                                            {
710                                              if (((word >> 31) & 0x1) == 0)
711                                                {
712                                                  if (((word >> 30) & 0x1) == 0)
713                                                    {
714                                                      /* 33222222222211111111110000000000
715                                                         10987654321098765432109876543210
716                                                         xxxxxxxxxx00xxxxxxxxx01000011100
717                                                         ldurb.  */
718                                                      return 702;
719                                                    }
720                                                  else
721                                                    {
722                                                      /* 33222222222211111111110000000000
723                                                         10987654321098765432109876543210
724                                                         xxxxxxxxxx00xxxxxxxxx01000011110
725                                                         ldurh.  */
726                                                      return 707;
727                                                    }
728                                                }
729                                              else
730                                                {
731                                                  /* 33222222222211111111110000000000
732                                                     10987654321098765432109876543210
733                                                     xxxxxxxxxx00xxxxxxxxx010000111x1
734                                                     ldur.  */
735                                                  return 710;
736                                                }
737                                            }
738                                        }
739                                      else
740                                        {
741                                          if (((word >> 30) & 0x1) == 0)
742                                            {
743                                              if (((word >> 31) & 0x1) == 0)
744                                                {
745                                                  /* 33222222222211111111110000000000
746                                                     10987654321098765432109876543210
747                                                     xxxxxxxxxx00xxxxxxxxx0x100011100
748                                                     ldursb.  */
749                                                  return 703;
750                                                }
751                                              else
752                                                {
753                                                  /* 33222222222211111111110000000000
754                                                     10987654321098765432109876543210
755                                                     xxxxxxxxxx00xxxxxxxxx0x100011101
756                                                     ldursw.  */
757                                                  return 711;
758                                                }
759                                            }
760                                          else
761                                            {
762                                              if (((word >> 31) & 0x1) == 0)
763                                                {
764                                                  /* 33222222222211111111110000000000
765                                                     10987654321098765432109876543210
766                                                     xxxxxxxxxx00xxxxxxxxx0x100011110
767                                                     ldursh.  */
768                                                  return 708;
769                                                }
770                                              else
771                                                {
772                                                  /* 33222222222211111111110000000000
773                                                     10987654321098765432109876543210
774                                                     xxxxxxxxxx00xxxxxxxxx0x100011111
775                                                     prfum.  */
776                                                  return 712;
777                                                }
778                                            }
779                                        }
780                                    }
781                                  else
782                                    {
783                                      if (((word >> 12) & 0x1) == 0)
784                                        {
785                                          if (((word >> 13) & 0x1) == 0)
786                                            {
787                                              if (((word >> 14) & 0x1) == 0)
788                                                {
789                                                  if (((word >> 15) & 0x1) == 0)
790                                                    {
791                                                      if (((word >> 22) & 0x1) == 0)
792                                                        {
793                                                          if (((word >> 23) & 0x1) == 0)
794                                                            {
795                                                              if (((word >> 31) & 0x1) == 0)
796                                                                {
797                                                                  if (((word >> 30) & 0x1) == 0)
798                                                                    {
799                                                                      /* 33222222222211111111110000000000
800                                                                         10987654321098765432109876543210
801                                                                         xxxxxxxxxx000000xxxxx10000011100
802                                                                         ldaddb.  */
803                                                                      return 806;
804                                                                    }
805                                                                  else
806                                                                    {
807                                                                      /* 33222222222211111111110000000000
808                                                                         10987654321098765432109876543210
809                                                                         xxxxxxxxxx000000xxxxx10000011110
810                                                                         ldaddh.  */
811                                                                      return 807;
812                                                                    }
813                                                                }
814                                                              else
815                                                                {
816                                                                  /* 33222222222211111111110000000000
817                                                                     10987654321098765432109876543210
818                                                                     xxxxxxxxxx000000xxxxx100000111x1
819                                                                     ldadd.  */
820                                                                  return 808;
821                                                                }
822                                                            }
823                                                          else
824                                                            {
825                                                              if (((word >> 31) & 0x1) == 0)
826                                                                {
827                                                                  if (((word >> 30) & 0x1) == 0)
828                                                                    {
829                                                                      /* 33222222222211111111110000000000
830                                                                         10987654321098765432109876543210
831                                                                         xxxxxxxxxx000000xxxxx10100011100
832                                                                         ldaddab.  */
833                                                                      return 809;
834                                                                    }
835                                                                  else
836                                                                    {
837                                                                      /* 33222222222211111111110000000000
838                                                                         10987654321098765432109876543210
839                                                                         xxxxxxxxxx000000xxxxx10100011110
840                                                                         ldaddah.  */
841                                                                      return 812;
842                                                                    }
843                                                                }
844                                                              else
845                                                                {
846                                                                  /* 33222222222211111111110000000000
847                                                                     10987654321098765432109876543210
848                                                                     xxxxxxxxxx000000xxxxx101000111x1
849                                                                     ldadda.  */
850                                                                  return 815;
851                                                                }
852                                                            }
853                                                        }
854                                                      else
855                                                        {
856                                                          if (((word >> 23) & 0x1) == 0)
857                                                            {
858                                                              if (((word >> 31) & 0x1) == 0)
859                                                                {
860                                                                  if (((word >> 30) & 0x1) == 0)
861                                                                    {
862                                                                      /* 33222222222211111111110000000000
863                                                                         10987654321098765432109876543210
864                                                                         xxxxxxxxxx000000xxxxx11000011100
865                                                                         ldaddlb.  */
866                                                                      return 810;
867                                                                    }
868                                                                  else
869                                                                    {
870                                                                      /* 33222222222211111111110000000000
871                                                                         10987654321098765432109876543210
872                                                                         xxxxxxxxxx000000xxxxx11000011110
873                                                                         ldaddlh.  */
874                                                                      return 813;
875                                                                    }
876                                                                }
877                                                              else
878                                                                {
879                                                                  /* 33222222222211111111110000000000
880                                                                     10987654321098765432109876543210
881                                                                     xxxxxxxxxx000000xxxxx110000111x1
882                                                                     ldaddl.  */
883                                                                  return 816;
884                                                                }
885                                                            }
886                                                          else
887                                                            {
888                                                              if (((word >> 31) & 0x1) == 0)
889                                                                {
890                                                                  if (((word >> 30) & 0x1) == 0)
891                                                                    {
892                                                                      /* 33222222222211111111110000000000
893                                                                         10987654321098765432109876543210
894                                                                         xxxxxxxxxx000000xxxxx11100011100
895                                                                         ldaddalb.  */
896                                                                      return 811;
897                                                                    }
898                                                                  else
899                                                                    {
900                                                                      /* 33222222222211111111110000000000
901                                                                         10987654321098765432109876543210
902                                                                         xxxxxxxxxx000000xxxxx11100011110
903                                                                         ldaddalh.  */
904                                                                      return 814;
905                                                                    }
906                                                                }
907                                                              else
908                                                                {
909                                                                  /* 33222222222211111111110000000000
910                                                                     10987654321098765432109876543210
911                                                                     xxxxxxxxxx000000xxxxx111000111x1
912                                                                     ldaddal.  */
913                                                                  return 817;
914                                                                }
915                                                            }
916                                                        }
917                                                    }
918                                                  else
919                                                    {
920                                                      if (((word >> 22) & 0x1) == 0)
921                                                        {
922                                                          if (((word >> 23) & 0x1) == 0)
923                                                            {
924                                                              if (((word >> 31) & 0x1) == 0)
925                                                                {
926                                                                  if (((word >> 30) & 0x1) == 0)
927                                                                    {
928                                                                      /* 33222222222211111111110000000000
929                                                                         10987654321098765432109876543210
930                                                                         xxxxxxxxxx000001xxxxx10000011100
931                                                                         swpb.  */
932                                                                      return 794;
933                                                                    }
934                                                                  else
935                                                                    {
936                                                                      /* 33222222222211111111110000000000
937                                                                         10987654321098765432109876543210
938                                                                         xxxxxxxxxx000001xxxxx10000011110
939                                                                         swph.  */
940                                                                      return 795;
941                                                                    }
942                                                                }
943                                                              else
944                                                                {
945                                                                  /* 33222222222211111111110000000000
946                                                                     10987654321098765432109876543210
947                                                                     xxxxxxxxxx000001xxxxx100000111x1
948                                                                     swp.  */
949                                                                  return 796;
950                                                                }
951                                                            }
952                                                          else
953                                                            {
954                                                              if (((word >> 31) & 0x1) == 0)
955                                                                {
956                                                                  if (((word >> 30) & 0x1) == 0)
957                                                                    {
958                                                                      /* 33222222222211111111110000000000
959                                                                         10987654321098765432109876543210
960                                                                         xxxxxxxxxx000001xxxxx10100011100
961                                                                         swpab.  */
962                                                                      return 797;
963                                                                    }
964                                                                  else
965                                                                    {
966                                                                      /* 33222222222211111111110000000000
967                                                                         10987654321098765432109876543210
968                                                                         xxxxxxxxxx000001xxxxx10100011110
969                                                                         swpah.  */
970                                                                      return 800;
971                                                                    }
972                                                                }
973                                                              else
974                                                                {
975                                                                  /* 33222222222211111111110000000000
976                                                                     10987654321098765432109876543210
977                                                                     xxxxxxxxxx000001xxxxx101000111x1
978                                                                     swpa.  */
979                                                                  return 803;
980                                                                }
981                                                            }
982                                                        }
983                                                      else
984                                                        {
985                                                          if (((word >> 23) & 0x1) == 0)
986                                                            {
987                                                              if (((word >> 31) & 0x1) == 0)
988                                                                {
989                                                                  if (((word >> 30) & 0x1) == 0)
990                                                                    {
991                                                                      /* 33222222222211111111110000000000
992                                                                         10987654321098765432109876543210
993                                                                         xxxxxxxxxx000001xxxxx11000011100
994                                                                         swplb.  */
995                                                                      return 798;
996                                                                    }
997                                                                  else
998                                                                    {
999                                                                      /* 33222222222211111111110000000000
1000                                                                         10987654321098765432109876543210
1001                                                                         xxxxxxxxxx000001xxxxx11000011110
1002                                                                         swplh.  */
1003                                                                      return 801;
1004                                                                    }
1005                                                                }
1006                                                              else
1007                                                                {
1008                                                                  /* 33222222222211111111110000000000
1009                                                                     10987654321098765432109876543210
1010                                                                     xxxxxxxxxx000001xxxxx110000111x1
1011                                                                     swpl.  */
1012                                                                  return 804;
1013                                                                }
1014                                                            }
1015                                                          else
1016                                                            {
1017                                                              if (((word >> 31) & 0x1) == 0)
1018                                                                {
1019                                                                  if (((word >> 30) & 0x1) == 0)
1020                                                                    {
1021                                                                      /* 33222222222211111111110000000000
1022                                                                         10987654321098765432109876543210
1023                                                                         xxxxxxxxxx000001xxxxx11100011100
1024                                                                         swpalb.  */
1025                                                                      return 799;
1026                                                                    }
1027                                                                  else
1028                                                                    {
1029                                                                      /* 33222222222211111111110000000000
1030                                                                         10987654321098765432109876543210
1031                                                                         xxxxxxxxxx000001xxxxx11100011110
1032                                                                         swpalh.  */
1033                                                                      return 802;
1034                                                                    }
1035                                                                }
1036                                                              else
1037                                                                {
1038                                                                  /* 33222222222211111111110000000000
1039                                                                     10987654321098765432109876543210
1040                                                                     xxxxxxxxxx000001xxxxx111000111x1
1041                                                                     swpal.  */
1042                                                                  return 805;
1043                                                                }
1044                                                            }
1045                                                        }
1046                                                    }
1047                                                }
1048                                              else
1049                                                {
1050                                                  if (((word >> 22) & 0x1) == 0)
1051                                                    {
1052                                                      if (((word >> 23) & 0x1) == 0)
1053                                                        {
1054                                                          if (((word >> 31) & 0x1) == 0)
1055                                                            {
1056                                                              if (((word >> 30) & 0x1) == 0)
1057                                                                {
1058                                                                  /* 33222222222211111111110000000000
1059                                                                     10987654321098765432109876543210
1060                                                                     xxxxxxxxxx00001xxxxxx10000011100
1061                                                                     ldsmaxb.  */
1062                                                                  return 854;
1063                                                                }
1064                                                              else
1065                                                                {
1066                                                                  /* 33222222222211111111110000000000
1067                                                                     10987654321098765432109876543210
1068                                                                     xxxxxxxxxx00001xxxxxx10000011110
1069                                                                     ldsmaxh.  */
1070                                                                  return 855;
1071                                                                }
1072                                                            }
1073                                                          else
1074                                                            {
1075                                                              /* 33222222222211111111110000000000
1076                                                                 10987654321098765432109876543210
1077                                                                 xxxxxxxxxx00001xxxxxx100000111x1
1078                                                                 ldsmax.  */
1079                                                              return 856;
1080                                                            }
1081                                                        }
1082                                                      else
1083                                                        {
1084                                                          if (((word >> 31) & 0x1) == 0)
1085                                                            {
1086                                                              if (((word >> 30) & 0x1) == 0)
1087                                                                {
1088                                                                  /* 33222222222211111111110000000000
1089                                                                     10987654321098765432109876543210
1090                                                                     xxxxxxxxxx00001xxxxxx10100011100
1091                                                                     ldsmaxab.  */
1092                                                                  return 857;
1093                                                                }
1094                                                              else
1095                                                                {
1096                                                                  /* 33222222222211111111110000000000
1097                                                                     10987654321098765432109876543210
1098                                                                     xxxxxxxxxx00001xxxxxx10100011110
1099                                                                     ldsmaxah.  */
1100                                                                  return 860;
1101                                                                }
1102                                                            }
1103                                                          else
1104                                                            {
1105                                                              /* 33222222222211111111110000000000
1106                                                                 10987654321098765432109876543210
1107                                                                 xxxxxxxxxx00001xxxxxx101000111x1
1108                                                                 ldsmaxa.  */
1109                                                              return 863;
1110                                                            }
1111                                                        }
1112                                                    }
1113                                                  else
1114                                                    {
1115                                                      if (((word >> 23) & 0x1) == 0)
1116                                                        {
1117                                                          if (((word >> 31) & 0x1) == 0)
1118                                                            {
1119                                                              if (((word >> 30) & 0x1) == 0)
1120                                                                {
1121                                                                  /* 33222222222211111111110000000000
1122                                                                     10987654321098765432109876543210
1123                                                                     xxxxxxxxxx00001xxxxxx11000011100
1124                                                                     ldsmaxlb.  */
1125                                                                  return 858;
1126                                                                }
1127                                                              else
1128                                                                {
1129                                                                  /* 33222222222211111111110000000000
1130                                                                     10987654321098765432109876543210
1131                                                                     xxxxxxxxxx00001xxxxxx11000011110
1132                                                                     ldsmaxlh.  */
1133                                                                  return 861;
1134                                                                }
1135                                                            }
1136                                                          else
1137                                                            {
1138                                                              /* 33222222222211111111110000000000
1139                                                                 10987654321098765432109876543210
1140                                                                 xxxxxxxxxx00001xxxxxx110000111x1
1141                                                                 ldsmaxl.  */
1142                                                              return 864;
1143                                                            }
1144                                                        }
1145                                                      else
1146                                                        {
1147                                                          if (((word >> 31) & 0x1) == 0)
1148                                                            {
1149                                                              if (((word >> 30) & 0x1) == 0)
1150                                                                {
1151                                                                  /* 33222222222211111111110000000000
1152                                                                     10987654321098765432109876543210
1153                                                                     xxxxxxxxxx00001xxxxxx11100011100
1154                                                                     ldsmaxalb.  */
1155                                                                  return 859;
1156                                                                }
1157                                                              else
1158                                                                {
1159                                                                  /* 33222222222211111111110000000000
1160                                                                     10987654321098765432109876543210
1161                                                                     xxxxxxxxxx00001xxxxxx11100011110
1162                                                                     ldsmaxalh.  */
1163                                                                  return 862;
1164                                                                }
1165                                                            }
1166                                                          else
1167                                                            {
1168                                                              /* 33222222222211111111110000000000
1169                                                                 10987654321098765432109876543210
1170                                                                 xxxxxxxxxx00001xxxxxx111000111x1
1171                                                                 ldsmaxal.  */
1172                                                              return 865;
1173                                                            }
1174                                                        }
1175                                                    }
1176                                                }
1177                                            }
1178                                          else
1179                                            {
1180                                              if (((word >> 14) & 0x1) == 0)
1181                                                {
1182                                                  if (((word >> 22) & 0x1) == 0)
1183                                                    {
1184                                                      if (((word >> 23) & 0x1) == 0)
1185                                                        {
1186                                                          if (((word >> 31) & 0x1) == 0)
1187                                                            {
1188                                                              if (((word >> 30) & 0x1) == 0)
1189                                                                {
1190                                                                  /* 33222222222211111111110000000000
1191                                                                     10987654321098765432109876543210
1192                                                                     xxxxxxxxxx00010xxxxxx10000011100
1193                                                                     ldeorb.  */
1194                                                                  return 830;
1195                                                                }
1196                                                              else
1197                                                                {
1198                                                                  /* 33222222222211111111110000000000
1199                                                                     10987654321098765432109876543210
1200                                                                     xxxxxxxxxx00010xxxxxx10000011110
1201                                                                     ldeorh.  */
1202                                                                  return 831;
1203                                                                }
1204                                                            }
1205                                                          else
1206                                                            {
1207                                                              /* 33222222222211111111110000000000
1208                                                                 10987654321098765432109876543210
1209                                                                 xxxxxxxxxx00010xxxxxx100000111x1
1210                                                                 ldeor.  */
1211                                                              return 832;
1212                                                            }
1213                                                        }
1214                                                      else
1215                                                        {
1216                                                          if (((word >> 31) & 0x1) == 0)
1217                                                            {
1218                                                              if (((word >> 30) & 0x1) == 0)
1219                                                                {
1220                                                                  /* 33222222222211111111110000000000
1221                                                                     10987654321098765432109876543210
1222                                                                     xxxxxxxxxx00010xxxxxx10100011100
1223                                                                     ldeorab.  */
1224                                                                  return 833;
1225                                                                }
1226                                                              else
1227                                                                {
1228                                                                  /* 33222222222211111111110000000000
1229                                                                     10987654321098765432109876543210
1230                                                                     xxxxxxxxxx00010xxxxxx10100011110
1231                                                                     ldeorah.  */
1232                                                                  return 836;
1233                                                                }
1234                                                            }
1235                                                          else
1236                                                            {
1237                                                              /* 33222222222211111111110000000000
1238                                                                 10987654321098765432109876543210
1239                                                                 xxxxxxxxxx00010xxxxxx101000111x1
1240                                                                 ldeora.  */
1241                                                              return 839;
1242                                                            }
1243                                                        }
1244                                                    }
1245                                                  else
1246                                                    {
1247                                                      if (((word >> 23) & 0x1) == 0)
1248                                                        {
1249                                                          if (((word >> 31) & 0x1) == 0)
1250                                                            {
1251                                                              if (((word >> 30) & 0x1) == 0)
1252                                                                {
1253                                                                  /* 33222222222211111111110000000000
1254                                                                     10987654321098765432109876543210
1255                                                                     xxxxxxxxxx00010xxxxxx11000011100
1256                                                                     ldeorlb.  */
1257                                                                  return 834;
1258                                                                }
1259                                                              else
1260                                                                {
1261                                                                  /* 33222222222211111111110000000000
1262                                                                     10987654321098765432109876543210
1263                                                                     xxxxxxxxxx00010xxxxxx11000011110
1264                                                                     ldeorlh.  */
1265                                                                  return 837;
1266                                                                }
1267                                                            }
1268                                                          else
1269                                                            {
1270                                                              /* 33222222222211111111110000000000
1271                                                                 10987654321098765432109876543210
1272                                                                 xxxxxxxxxx00010xxxxxx110000111x1
1273                                                                 ldeorl.  */
1274                                                              return 840;
1275                                                            }
1276                                                        }
1277                                                      else
1278                                                        {
1279                                                          if (((word >> 31) & 0x1) == 0)
1280                                                            {
1281                                                              if (((word >> 30) & 0x1) == 0)
1282                                                                {
1283                                                                  /* 33222222222211111111110000000000
1284                                                                     10987654321098765432109876543210
1285                                                                     xxxxxxxxxx00010xxxxxx11100011100
1286                                                                     ldeoralb.  */
1287                                                                  return 835;
1288                                                                }
1289                                                              else
1290                                                                {
1291                                                                  /* 33222222222211111111110000000000
1292                                                                     10987654321098765432109876543210
1293                                                                     xxxxxxxxxx00010xxxxxx11100011110
1294                                                                     ldeoralh.  */
1295                                                                  return 838;
1296                                                                }
1297                                                            }
1298                                                          else
1299                                                            {
1300                                                              /* 33222222222211111111110000000000
1301                                                                 10987654321098765432109876543210
1302                                                                 xxxxxxxxxx00010xxxxxx111000111x1
1303                                                                 ldeoral.  */
1304                                                              return 841;
1305                                                            }
1306                                                        }
1307                                                    }
1308                                                }
1309                                              else
1310                                                {
1311                                                  if (((word >> 22) & 0x1) == 0)
1312                                                    {
1313                                                      if (((word >> 23) & 0x1) == 0)
1314                                                        {
1315                                                          if (((word >> 31) & 0x1) == 0)
1316                                                            {
1317                                                              if (((word >> 30) & 0x1) == 0)
1318                                                                {
1319                                                                  /* 33222222222211111111110000000000
1320                                                                     10987654321098765432109876543210
1321                                                                     xxxxxxxxxx00011xxxxxx10000011100
1322                                                                     ldumaxb.  */
1323                                                                  return 878;
1324                                                                }
1325                                                              else
1326                                                                {
1327                                                                  /* 33222222222211111111110000000000
1328                                                                     10987654321098765432109876543210
1329                                                                     xxxxxxxxxx00011xxxxxx10000011110
1330                                                                     ldumaxh.  */
1331                                                                  return 879;
1332                                                                }
1333                                                            }
1334                                                          else
1335                                                            {
1336                                                              /* 33222222222211111111110000000000
1337                                                                 10987654321098765432109876543210
1338                                                                 xxxxxxxxxx00011xxxxxx100000111x1
1339                                                                 ldumax.  */
1340                                                              return 880;
1341                                                            }
1342                                                        }
1343                                                      else
1344                                                        {
1345                                                          if (((word >> 31) & 0x1) == 0)
1346                                                            {
1347                                                              if (((word >> 30) & 0x1) == 0)
1348                                                                {
1349                                                                  /* 33222222222211111111110000000000
1350                                                                     10987654321098765432109876543210
1351                                                                     xxxxxxxxxx00011xxxxxx10100011100
1352                                                                     ldumaxab.  */
1353                                                                  return 881;
1354                                                                }
1355                                                              else
1356                                                                {
1357                                                                  /* 33222222222211111111110000000000
1358                                                                     10987654321098765432109876543210
1359                                                                     xxxxxxxxxx00011xxxxxx10100011110
1360                                                                     ldumaxah.  */
1361                                                                  return 884;
1362                                                                }
1363                                                            }
1364                                                          else
1365                                                            {
1366                                                              /* 33222222222211111111110000000000
1367                                                                 10987654321098765432109876543210
1368                                                                 xxxxxxxxxx00011xxxxxx101000111x1
1369                                                                 ldumaxa.  */
1370                                                              return 887;
1371                                                            }
1372                                                        }
1373                                                    }
1374                                                  else
1375                                                    {
1376                                                      if (((word >> 23) & 0x1) == 0)
1377                                                        {
1378                                                          if (((word >> 31) & 0x1) == 0)
1379                                                            {
1380                                                              if (((word >> 30) & 0x1) == 0)
1381                                                                {
1382                                                                  /* 33222222222211111111110000000000
1383                                                                     10987654321098765432109876543210
1384                                                                     xxxxxxxxxx00011xxxxxx11000011100
1385                                                                     ldumaxlb.  */
1386                                                                  return 882;
1387                                                                }
1388                                                              else
1389                                                                {
1390                                                                  /* 33222222222211111111110000000000
1391                                                                     10987654321098765432109876543210
1392                                                                     xxxxxxxxxx00011xxxxxx11000011110
1393                                                                     ldumaxlh.  */
1394                                                                  return 885;
1395                                                                }
1396                                                            }
1397                                                          else
1398                                                            {
1399                                                              /* 33222222222211111111110000000000
1400                                                                 10987654321098765432109876543210
1401                                                                 xxxxxxxxxx00011xxxxxx110000111x1
1402                                                                 ldumaxl.  */
1403                                                              return 888;
1404                                                            }
1405                                                        }
1406                                                      else
1407                                                        {
1408                                                          if (((word >> 31) & 0x1) == 0)
1409                                                            {
1410                                                              if (((word >> 30) & 0x1) == 0)
1411                                                                {
1412                                                                  /* 33222222222211111111110000000000
1413                                                                     10987654321098765432109876543210
1414                                                                     xxxxxxxxxx00011xxxxxx11100011100
1415                                                                     ldumaxalb.  */
1416                                                                  return 883;
1417                                                                }
1418                                                              else
1419                                                                {
1420                                                                  /* 33222222222211111111110000000000
1421                                                                     10987654321098765432109876543210
1422                                                                     xxxxxxxxxx00011xxxxxx11100011110
1423                                                                     ldumaxalh.  */
1424                                                                  return 886;
1425                                                                }
1426                                                            }
1427                                                          else
1428                                                            {
1429                                                              /* 33222222222211111111110000000000
1430                                                                 10987654321098765432109876543210
1431                                                                 xxxxxxxxxx00011xxxxxx111000111x1
1432                                                                 ldumaxal.  */
1433                                                              return 889;
1434                                                            }
1435                                                        }
1436                                                    }
1437                                                }
1438                                            }
1439                                        }
1440                                      else
1441                                        {
1442                                          if (((word >> 13) & 0x1) == 0)
1443                                            {
1444                                              if (((word >> 14) & 0x1) == 0)
1445                                                {
1446                                                  if (((word >> 22) & 0x1) == 0)
1447                                                    {
1448                                                      if (((word >> 23) & 0x1) == 0)
1449                                                        {
1450                                                          if (((word >> 31) & 0x1) == 0)
1451                                                            {
1452                                                              if (((word >> 30) & 0x1) == 0)
1453                                                                {
1454                                                                  /* 33222222222211111111110000000000
1455                                                                     10987654321098765432109876543210
1456                                                                     xxxxxxxxxx00100xxxxxx10000011100
1457                                                                     ldclrb.  */
1458                                                                  return 818;
1459                                                                }
1460                                                              else
1461                                                                {
1462                                                                  /* 33222222222211111111110000000000
1463                                                                     10987654321098765432109876543210
1464                                                                     xxxxxxxxxx00100xxxxxx10000011110
1465                                                                     ldclrh.  */
1466                                                                  return 819;
1467                                                                }
1468                                                            }
1469                                                          else
1470                                                            {
1471                                                              /* 33222222222211111111110000000000
1472                                                                 10987654321098765432109876543210
1473                                                                 xxxxxxxxxx00100xxxxxx100000111x1
1474                                                                 ldclr.  */
1475                                                              return 820;
1476                                                            }
1477                                                        }
1478                                                      else
1479                                                        {
1480                                                          if (((word >> 31) & 0x1) == 0)
1481                                                            {
1482                                                              if (((word >> 30) & 0x1) == 0)
1483                                                                {
1484                                                                  /* 33222222222211111111110000000000
1485                                                                     10987654321098765432109876543210
1486                                                                     xxxxxxxxxx00100xxxxxx10100011100
1487                                                                     ldclrab.  */
1488                                                                  return 821;
1489                                                                }
1490                                                              else
1491                                                                {
1492                                                                  /* 33222222222211111111110000000000
1493                                                                     10987654321098765432109876543210
1494                                                                     xxxxxxxxxx00100xxxxxx10100011110
1495                                                                     ldclrah.  */
1496                                                                  return 824;
1497                                                                }
1498                                                            }
1499                                                          else
1500                                                            {
1501                                                              /* 33222222222211111111110000000000
1502                                                                 10987654321098765432109876543210
1503                                                                 xxxxxxxxxx00100xxxxxx101000111x1
1504                                                                 ldclra.  */
1505                                                              return 827;
1506                                                            }
1507                                                        }
1508                                                    }
1509                                                  else
1510                                                    {
1511                                                      if (((word >> 23) & 0x1) == 0)
1512                                                        {
1513                                                          if (((word >> 31) & 0x1) == 0)
1514                                                            {
1515                                                              if (((word >> 30) & 0x1) == 0)
1516                                                                {
1517                                                                  /* 33222222222211111111110000000000
1518                                                                     10987654321098765432109876543210
1519                                                                     xxxxxxxxxx00100xxxxxx11000011100
1520                                                                     ldclrlb.  */
1521                                                                  return 822;
1522                                                                }
1523                                                              else
1524                                                                {
1525                                                                  /* 33222222222211111111110000000000
1526                                                                     10987654321098765432109876543210
1527                                                                     xxxxxxxxxx00100xxxxxx11000011110
1528                                                                     ldclrlh.  */
1529                                                                  return 825;
1530                                                                }
1531                                                            }
1532                                                          else
1533                                                            {
1534                                                              /* 33222222222211111111110000000000
1535                                                                 10987654321098765432109876543210
1536                                                                 xxxxxxxxxx00100xxxxxx110000111x1
1537                                                                 ldclrl.  */
1538                                                              return 828;
1539                                                            }
1540                                                        }
1541                                                      else
1542                                                        {
1543                                                          if (((word >> 31) & 0x1) == 0)
1544                                                            {
1545                                                              if (((word >> 30) & 0x1) == 0)
1546                                                                {
1547                                                                  /* 33222222222211111111110000000000
1548                                                                     10987654321098765432109876543210
1549                                                                     xxxxxxxxxx00100xxxxxx11100011100
1550                                                                     ldclralb.  */
1551                                                                  return 823;
1552                                                                }
1553                                                              else
1554                                                                {
1555                                                                  /* 33222222222211111111110000000000
1556                                                                     10987654321098765432109876543210
1557                                                                     xxxxxxxxxx00100xxxxxx11100011110
1558                                                                     ldclralh.  */
1559                                                                  return 826;
1560                                                                }
1561                                                            }
1562                                                          else
1563                                                            {
1564                                                              /* 33222222222211111111110000000000
1565                                                                 10987654321098765432109876543210
1566                                                                 xxxxxxxxxx00100xxxxxx111000111x1
1567                                                                 ldclral.  */
1568                                                              return 829;
1569                                                            }
1570                                                        }
1571                                                    }
1572                                                }
1573                                              else
1574                                                {
1575                                                  if (((word >> 22) & 0x1) == 0)
1576                                                    {
1577                                                      if (((word >> 23) & 0x1) == 0)
1578                                                        {
1579                                                          if (((word >> 31) & 0x1) == 0)
1580                                                            {
1581                                                              if (((word >> 30) & 0x1) == 0)
1582                                                                {
1583                                                                  /* 33222222222211111111110000000000
1584                                                                     10987654321098765432109876543210
1585                                                                     xxxxxxxxxx00101xxxxxx10000011100
1586                                                                     ldsminb.  */
1587                                                                  return 866;
1588                                                                }
1589                                                              else
1590                                                                {
1591                                                                  /* 33222222222211111111110000000000
1592                                                                     10987654321098765432109876543210
1593                                                                     xxxxxxxxxx00101xxxxxx10000011110
1594                                                                     ldsminh.  */
1595                                                                  return 867;
1596                                                                }
1597                                                            }
1598                                                          else
1599                                                            {
1600                                                              /* 33222222222211111111110000000000
1601                                                                 10987654321098765432109876543210
1602                                                                 xxxxxxxxxx00101xxxxxx100000111x1
1603                                                                 ldsmin.  */
1604                                                              return 868;
1605                                                            }
1606                                                        }
1607                                                      else
1608                                                        {
1609                                                          if (((word >> 31) & 0x1) == 0)
1610                                                            {
1611                                                              if (((word >> 30) & 0x1) == 0)
1612                                                                {
1613                                                                  /* 33222222222211111111110000000000
1614                                                                     10987654321098765432109876543210
1615                                                                     xxxxxxxxxx00101xxxxxx10100011100
1616                                                                     ldsminab.  */
1617                                                                  return 869;
1618                                                                }
1619                                                              else
1620                                                                {
1621                                                                  /* 33222222222211111111110000000000
1622                                                                     10987654321098765432109876543210
1623                                                                     xxxxxxxxxx00101xxxxxx10100011110
1624                                                                     ldsminah.  */
1625                                                                  return 872;
1626                                                                }
1627                                                            }
1628                                                          else
1629                                                            {
1630                                                              /* 33222222222211111111110000000000
1631                                                                 10987654321098765432109876543210
1632                                                                 xxxxxxxxxx00101xxxxxx101000111x1
1633                                                                 ldsmina.  */
1634                                                              return 875;
1635                                                            }
1636                                                        }
1637                                                    }
1638                                                  else
1639                                                    {
1640                                                      if (((word >> 23) & 0x1) == 0)
1641                                                        {
1642                                                          if (((word >> 31) & 0x1) == 0)
1643                                                            {
1644                                                              if (((word >> 30) & 0x1) == 0)
1645                                                                {
1646                                                                  /* 33222222222211111111110000000000
1647                                                                     10987654321098765432109876543210
1648                                                                     xxxxxxxxxx00101xxxxxx11000011100
1649                                                                     ldsminlb.  */
1650                                                                  return 870;
1651                                                                }
1652                                                              else
1653                                                                {
1654                                                                  /* 33222222222211111111110000000000
1655                                                                     10987654321098765432109876543210
1656                                                                     xxxxxxxxxx00101xxxxxx11000011110
1657                                                                     ldsminlh.  */
1658                                                                  return 873;
1659                                                                }
1660                                                            }
1661                                                          else
1662                                                            {
1663                                                              /* 33222222222211111111110000000000
1664                                                                 10987654321098765432109876543210
1665                                                                 xxxxxxxxxx00101xxxxxx110000111x1
1666                                                                 ldsminl.  */
1667                                                              return 876;
1668                                                            }
1669                                                        }
1670                                                      else
1671                                                        {
1672                                                          if (((word >> 31) & 0x1) == 0)
1673                                                            {
1674                                                              if (((word >> 30) & 0x1) == 0)
1675                                                                {
1676                                                                  /* 33222222222211111111110000000000
1677                                                                     10987654321098765432109876543210
1678                                                                     xxxxxxxxxx00101xxxxxx11100011100
1679                                                                     ldsminalb.  */
1680                                                                  return 871;
1681                                                                }
1682                                                              else
1683                                                                {
1684                                                                  /* 33222222222211111111110000000000
1685                                                                     10987654321098765432109876543210
1686                                                                     xxxxxxxxxx00101xxxxxx11100011110
1687                                                                     ldsminalh.  */
1688                                                                  return 874;
1689                                                                }
1690                                                            }
1691                                                          else
1692                                                            {
1693                                                              /* 33222222222211111111110000000000
1694                                                                 10987654321098765432109876543210
1695                                                                 xxxxxxxxxx00101xxxxxx111000111x1
1696                                                                 ldsminal.  */
1697                                                              return 877;
1698                                                            }
1699                                                        }
1700                                                    }
1701                                                }
1702                                            }
1703                                          else
1704                                            {
1705                                              if (((word >> 14) & 0x1) == 0)
1706                                                {
1707                                                  if (((word >> 22) & 0x1) == 0)
1708                                                    {
1709                                                      if (((word >> 23) & 0x1) == 0)
1710                                                        {
1711                                                          if (((word >> 31) & 0x1) == 0)
1712                                                            {
1713                                                              if (((word >> 30) & 0x1) == 0)
1714                                                                {
1715                                                                  /* 33222222222211111111110000000000
1716                                                                     10987654321098765432109876543210
1717                                                                     xxxxxxxxxx00110xxxxxx10000011100
1718                                                                     ldsetb.  */
1719                                                                  return 842;
1720                                                                }
1721                                                              else
1722                                                                {
1723                                                                  /* 33222222222211111111110000000000
1724                                                                     10987654321098765432109876543210
1725                                                                     xxxxxxxxxx00110xxxxxx10000011110
1726                                                                     ldseth.  */
1727                                                                  return 843;
1728                                                                }
1729                                                            }
1730                                                          else
1731                                                            {
1732                                                              /* 33222222222211111111110000000000
1733                                                                 10987654321098765432109876543210
1734                                                                 xxxxxxxxxx00110xxxxxx100000111x1
1735                                                                 ldset.  */
1736                                                              return 844;
1737                                                            }
1738                                                        }
1739                                                      else
1740                                                        {
1741                                                          if (((word >> 31) & 0x1) == 0)
1742                                                            {
1743                                                              if (((word >> 30) & 0x1) == 0)
1744                                                                {
1745                                                                  /* 33222222222211111111110000000000
1746                                                                     10987654321098765432109876543210
1747                                                                     xxxxxxxxxx00110xxxxxx10100011100
1748                                                                     ldsetab.  */
1749                                                                  return 845;
1750                                                                }
1751                                                              else
1752                                                                {
1753                                                                  /* 33222222222211111111110000000000
1754                                                                     10987654321098765432109876543210
1755                                                                     xxxxxxxxxx00110xxxxxx10100011110
1756                                                                     ldsetah.  */
1757                                                                  return 848;
1758                                                                }
1759                                                            }
1760                                                          else
1761                                                            {
1762                                                              /* 33222222222211111111110000000000
1763                                                                 10987654321098765432109876543210
1764                                                                 xxxxxxxxxx00110xxxxxx101000111x1
1765                                                                 ldseta.  */
1766                                                              return 851;
1767                                                            }
1768                                                        }
1769                                                    }
1770                                                  else
1771                                                    {
1772                                                      if (((word >> 23) & 0x1) == 0)
1773                                                        {
1774                                                          if (((word >> 31) & 0x1) == 0)
1775                                                            {
1776                                                              if (((word >> 30) & 0x1) == 0)
1777                                                                {
1778                                                                  /* 33222222222211111111110000000000
1779                                                                     10987654321098765432109876543210
1780                                                                     xxxxxxxxxx00110xxxxxx11000011100
1781                                                                     ldsetlb.  */
1782                                                                  return 846;
1783                                                                }
1784                                                              else
1785                                                                {
1786                                                                  /* 33222222222211111111110000000000
1787                                                                     10987654321098765432109876543210
1788                                                                     xxxxxxxxxx00110xxxxxx11000011110
1789                                                                     ldsetlh.  */
1790                                                                  return 849;
1791                                                                }
1792                                                            }
1793                                                          else
1794                                                            {
1795                                                              /* 33222222222211111111110000000000
1796                                                                 10987654321098765432109876543210
1797                                                                 xxxxxxxxxx00110xxxxxx110000111x1
1798                                                                 ldsetl.  */
1799                                                              return 852;
1800                                                            }
1801                                                        }
1802                                                      else
1803                                                        {
1804                                                          if (((word >> 31) & 0x1) == 0)
1805                                                            {
1806                                                              if (((word >> 30) & 0x1) == 0)
1807                                                                {
1808                                                                  /* 33222222222211111111110000000000
1809                                                                     10987654321098765432109876543210
1810                                                                     xxxxxxxxxx00110xxxxxx11100011100
1811                                                                     ldsetalb.  */
1812                                                                  return 847;
1813                                                                }
1814                                                              else
1815                                                                {
1816                                                                  /* 33222222222211111111110000000000
1817                                                                     10987654321098765432109876543210
1818                                                                     xxxxxxxxxx00110xxxxxx11100011110
1819                                                                     ldsetalh.  */
1820                                                                  return 850;
1821                                                                }
1822                                                            }
1823                                                          else
1824                                                            {
1825                                                              /* 33222222222211111111110000000000
1826                                                                 10987654321098765432109876543210
1827                                                                 xxxxxxxxxx00110xxxxxx111000111x1
1828                                                                 ldsetal.  */
1829                                                              return 853;
1830                                                            }
1831                                                        }
1832                                                    }
1833                                                }
1834                                              else
1835                                                {
1836                                                  if (((word >> 22) & 0x1) == 0)
1837                                                    {
1838                                                      if (((word >> 23) & 0x1) == 0)
1839                                                        {
1840                                                          if (((word >> 31) & 0x1) == 0)
1841                                                            {
1842                                                              if (((word >> 30) & 0x1) == 0)
1843                                                                {
1844                                                                  /* 33222222222211111111110000000000
1845                                                                     10987654321098765432109876543210
1846                                                                     xxxxxxxxxx00111xxxxxx10000011100
1847                                                                     lduminb.  */
1848                                                                  return 890;
1849                                                                }
1850                                                              else
1851                                                                {
1852                                                                  /* 33222222222211111111110000000000
1853                                                                     10987654321098765432109876543210
1854                                                                     xxxxxxxxxx00111xxxxxx10000011110
1855                                                                     lduminh.  */
1856                                                                  return 891;
1857                                                                }
1858                                                            }
1859                                                          else
1860                                                            {
1861                                                              /* 33222222222211111111110000000000
1862                                                                 10987654321098765432109876543210
1863                                                                 xxxxxxxxxx00111xxxxxx100000111x1
1864                                                                 ldumin.  */
1865                                                              return 892;
1866                                                            }
1867                                                        }
1868                                                      else
1869                                                        {
1870                                                          if (((word >> 31) & 0x1) == 0)
1871                                                            {
1872                                                              if (((word >> 30) & 0x1) == 0)
1873                                                                {
1874                                                                  /* 33222222222211111111110000000000
1875                                                                     10987654321098765432109876543210
1876                                                                     xxxxxxxxxx00111xxxxxx10100011100
1877                                                                     lduminab.  */
1878                                                                  return 893;
1879                                                                }
1880                                                              else
1881                                                                {
1882                                                                  /* 33222222222211111111110000000000
1883                                                                     10987654321098765432109876543210
1884                                                                     xxxxxxxxxx00111xxxxxx10100011110
1885                                                                     lduminah.  */
1886                                                                  return 896;
1887                                                                }
1888                                                            }
1889                                                          else
1890                                                            {
1891                                                              /* 33222222222211111111110000000000
1892                                                                 10987654321098765432109876543210
1893                                                                 xxxxxxxxxx00111xxxxxx101000111x1
1894                                                                 ldumina.  */
1895                                                              return 899;
1896                                                            }
1897                                                        }
1898                                                    }
1899                                                  else
1900                                                    {
1901                                                      if (((word >> 23) & 0x1) == 0)
1902                                                        {
1903                                                          if (((word >> 31) & 0x1) == 0)
1904                                                            {
1905                                                              if (((word >> 30) & 0x1) == 0)
1906                                                                {
1907                                                                  /* 33222222222211111111110000000000
1908                                                                     10987654321098765432109876543210
1909                                                                     xxxxxxxxxx00111xxxxxx11000011100
1910                                                                     lduminlb.  */
1911                                                                  return 894;
1912                                                                }
1913                                                              else
1914                                                                {
1915                                                                  /* 33222222222211111111110000000000
1916                                                                     10987654321098765432109876543210
1917                                                                     xxxxxxxxxx00111xxxxxx11000011110
1918                                                                     lduminlh.  */
1919                                                                  return 897;
1920                                                                }
1921                                                            }
1922                                                          else
1923                                                            {
1924                                                              /* 33222222222211111111110000000000
1925                                                                 10987654321098765432109876543210
1926                                                                 xxxxxxxxxx00111xxxxxx110000111x1
1927                                                                 lduminl.  */
1928                                                              return 900;
1929                                                            }
1930                                                        }
1931                                                      else
1932                                                        {
1933                                                          if (((word >> 31) & 0x1) == 0)
1934                                                            {
1935                                                              if (((word >> 30) & 0x1) == 0)
1936                                                                {
1937                                                                  /* 33222222222211111111110000000000
1938                                                                     10987654321098765432109876543210
1939                                                                     xxxxxxxxxx00111xxxxxx11100011100
1940                                                                     lduminalb.  */
1941                                                                  return 895;
1942                                                                }
1943                                                              else
1944                                                                {
1945                                                                  /* 33222222222211111111110000000000
1946                                                                     10987654321098765432109876543210
1947                                                                     xxxxxxxxxx00111xxxxxx11100011110
1948                                                                     lduminalh.  */
1949                                                                  return 898;
1950                                                                }
1951                                                            }
1952                                                          else
1953                                                            {
1954                                                              /* 33222222222211111111110000000000
1955                                                                 10987654321098765432109876543210
1956                                                                 xxxxxxxxxx00111xxxxxx111000111x1
1957                                                                 lduminal.  */
1958                                                              return 901;
1959                                                            }
1960                                                        }
1961                                                    }
1962                                                }
1963                                            }
1964                                        }
1965                                    }
1966                                }
1967                              else
1968                                {
1969                                  if (((word >> 21) & 0x1) == 0)
1970                                    {
1971                                      if (((word >> 23) & 0x1) == 0)
1972                                        {
1973                                          if (((word >> 22) & 0x1) == 0)
1974                                            {
1975                                              if (((word >> 31) & 0x1) == 0)
1976                                                {
1977                                                  if (((word >> 30) & 0x1) == 0)
1978                                                    {
1979                                                      /* 33222222222211111111110000000000
1980                                                         10987654321098765432109876543210
1981                                                         xxxxxxxxxx01xxxxxxxxx00000011100
1982                                                         sttrb.  */
1983                                                      return 692;
1984                                                    }
1985                                                  else
1986                                                    {
1987                                                      /* 33222222222211111111110000000000
1988                                                         10987654321098765432109876543210
1989                                                         xxxxxxxxxx01xxxxxxxxx00000011110
1990                                                         sttrh.  */
1991                                                      return 695;
1992                                                    }
1993                                                }
1994                                              else
1995                                                {
1996                                                  /* 33222222222211111111110000000000
1997                                                     10987654321098765432109876543210
1998                                                     xxxxxxxxxx01xxxxxxxxx000000111x1
1999                                                     sttr.  */
2000                                                  return 698;
2001                                                }
2002                                            }
2003                                          else
2004                                            {
2005                                              if (((word >> 31) & 0x1) == 0)
2006                                                {
2007                                                  if (((word >> 30) & 0x1) == 0)
2008                                                    {
2009                                                      /* 33222222222211111111110000000000
2010                                                         10987654321098765432109876543210
2011                                                         xxxxxxxxxx01xxxxxxxxx01000011100
2012                                                         ldtrb.  */
2013                                                      return 693;
2014                                                    }
2015                                                  else
2016                                                    {
2017                                                      /* 33222222222211111111110000000000
2018                                                         10987654321098765432109876543210
2019                                                         xxxxxxxxxx01xxxxxxxxx01000011110
2020                                                         ldtrh.  */
2021                                                      return 696;
2022                                                    }
2023                                                }
2024                                              else
2025                                                {
2026                                                  /* 33222222222211111111110000000000
2027                                                     10987654321098765432109876543210
2028                                                     xxxxxxxxxx01xxxxxxxxx010000111x1
2029                                                     ldtr.  */
2030                                                  return 699;
2031                                                }
2032                                            }
2033                                        }
2034                                      else
2035                                        {
2036                                          if (((word >> 30) & 0x1) == 0)
2037                                            {
2038                                              if (((word >> 31) & 0x1) == 0)
2039                                                {
2040                                                  /* 33222222222211111111110000000000
2041                                                     10987654321098765432109876543210
2042                                                     xxxxxxxxxx01xxxxxxxxx0x100011100
2043                                                     ldtrsb.  */
2044                                                  return 694;
2045                                                }
2046                                              else
2047                                                {
2048                                                  /* 33222222222211111111110000000000
2049                                                     10987654321098765432109876543210
2050                                                     xxxxxxxxxx01xxxxxxxxx0x100011101
2051                                                     ldtrsw.  */
2052                                                  return 700;
2053                                                }
2054                                            }
2055                                          else
2056                                            {
2057                                              /* 33222222222211111111110000000000
2058                                                 10987654321098765432109876543210
2059                                                 xxxxxxxxxx01xxxxxxxxx0x10001111x
2060                                                 ldtrsh.  */
2061                                              return 697;
2062                                            }
2063                                        }
2064                                    }
2065                                  else
2066                                    {
2067                                      if (((word >> 23) & 0x1) == 0)
2068                                        {
2069                                          if (((word >> 22) & 0x1) == 0)
2070                                            {
2071                                              if (((word >> 31) & 0x1) == 0)
2072                                                {
2073                                                  if (((word >> 30) & 0x1) == 0)
2074                                                    {
2075                                                      /* 33222222222211111111110000000000
2076                                                         10987654321098765432109876543210
2077                                                         xxxxxxxxxx01xxxxxxxxx10000011100
2078                                                         strb.  */
2079                                                      return 680;
2080                                                    }
2081                                                  else
2082                                                    {
2083                                                      /* 33222222222211111111110000000000
2084                                                         10987654321098765432109876543210
2085                                                         xxxxxxxxxx01xxxxxxxxx10000011110
2086                                                         strh.  */
2087                                                      return 685;
2088                                                    }
2089                                                }
2090                                              else
2091                                                {
2092                                                  /* 33222222222211111111110000000000
2093                                                     10987654321098765432109876543210
2094                                                     xxxxxxxxxx01xxxxxxxxx100000111x1
2095                                                     str.  */
2096                                                  return 688;
2097                                                }
2098                                            }
2099                                          else
2100                                            {
2101                                              if (((word >> 31) & 0x1) == 0)
2102                                                {
2103                                                  if (((word >> 30) & 0x1) == 0)
2104                                                    {
2105                                                      /* 33222222222211111111110000000000
2106                                                         10987654321098765432109876543210
2107                                                         xxxxxxxxxx01xxxxxxxxx11000011100
2108                                                         ldrb.  */
2109                                                      return 681;
2110                                                    }
2111                                                  else
2112                                                    {
2113                                                      /* 33222222222211111111110000000000
2114                                                         10987654321098765432109876543210
2115                                                         xxxxxxxxxx01xxxxxxxxx11000011110
2116                                                         ldrh.  */
2117                                                      return 686;
2118                                                    }
2119                                                }
2120                                              else
2121                                                {
2122                                                  /* 33222222222211111111110000000000
2123                                                     10987654321098765432109876543210
2124                                                     xxxxxxxxxx01xxxxxxxxx110000111x1
2125                                                     ldr.  */
2126                                                  return 689;
2127                                                }
2128                                            }
2129                                        }
2130                                      else
2131                                        {
2132                                          if (((word >> 30) & 0x1) == 0)
2133                                            {
2134                                              if (((word >> 31) & 0x1) == 0)
2135                                                {
2136                                                  /* 33222222222211111111110000000000
2137                                                     10987654321098765432109876543210
2138                                                     xxxxxxxxxx01xxxxxxxxx1x100011100
2139                                                     ldrsb.  */
2140                                                  return 682;
2141                                                }
2142                                              else
2143                                                {
2144                                                  /* 33222222222211111111110000000000
2145                                                     10987654321098765432109876543210
2146                                                     xxxxxxxxxx01xxxxxxxxx1x100011101
2147                                                     ldrsw.  */
2148                                                  return 690;
2149                                                }
2150                                            }
2151                                          else
2152                                            {
2153                                              if (((word >> 31) & 0x1) == 0)
2154                                                {
2155                                                  /* 33222222222211111111110000000000
2156                                                     10987654321098765432109876543210
2157                                                     xxxxxxxxxx01xxxxxxxxx1x100011110
2158                                                     ldrsh.  */
2159                                                  return 687;
2160                                                }
2161                                              else
2162                                                {
2163                                                  /* 33222222222211111111110000000000
2164                                                     10987654321098765432109876543210
2165                                                     xxxxxxxxxx01xxxxxxxxx1x100011111
2166                                                     prfm.  */
2167                                                  return 691;
2168                                                }
2169                                            }
2170                                        }
2171                                    }
2172                                }
2173                            }
2174                          else
2175                            {
2176                              if (((word >> 23) & 0x1) == 0)
2177                                {
2178                                  if (((word >> 22) & 0x1) == 0)
2179                                    {
2180                                      if (((word >> 31) & 0x1) == 0)
2181                                        {
2182                                          if (((word >> 30) & 0x1) == 0)
2183                                            {
2184                                              /* 33222222222211111111110000000000
2185                                                 10987654321098765432109876543210
2186                                                 xxxxxxxxxx1xxxxxxxxxxx0000011100
2187                                                 strb.  */
2188                                              return 657;
2189                                            }
2190                                          else
2191                                            {
2192                                              /* 33222222222211111111110000000000
2193                                                 10987654321098765432109876543210
2194                                                 xxxxxxxxxx1xxxxxxxxxxx0000011110
2195                                                 strh.  */
2196                                              return 662;
2197                                            }
2198                                        }
2199                                      else
2200                                        {
2201                                          /* 33222222222211111111110000000000
2202                                             10987654321098765432109876543210
2203                                             xxxxxxxxxx1xxxxxxxxxxx00000111x1
2204                                             str.  */
2205                                          return 665;
2206                                        }
2207                                    }
2208                                  else
2209                                    {
2210                                      if (((word >> 31) & 0x1) == 0)
2211                                        {
2212                                          if (((word >> 30) & 0x1) == 0)
2213                                            {
2214                                              /* 33222222222211111111110000000000
2215                                                 10987654321098765432109876543210
2216                                                 xxxxxxxxxx1xxxxxxxxxxx1000011100
2217                                                 ldrb.  */
2218                                              return 658;
2219                                            }
2220                                          else
2221                                            {
2222                                              /* 33222222222211111111110000000000
2223                                                 10987654321098765432109876543210
2224                                                 xxxxxxxxxx1xxxxxxxxxxx1000011110
2225                                                 ldrh.  */
2226                                              return 663;
2227                                            }
2228                                        }
2229                                      else
2230                                        {
2231                                          /* 33222222222211111111110000000000
2232                                             10987654321098765432109876543210
2233                                             xxxxxxxxxx1xxxxxxxxxxx10000111x1
2234                                             ldr.  */
2235                                          return 666;
2236                                        }
2237                                    }
2238                                }
2239                              else
2240                                {
2241                                  if (((word >> 30) & 0x1) == 0)
2242                                    {
2243                                      if (((word >> 31) & 0x1) == 0)
2244                                        {
2245                                          /* 33222222222211111111110000000000
2246                                             10987654321098765432109876543210
2247                                             xxxxxxxxxx1xxxxxxxxxxxx100011100
2248                                             ldrsb.  */
2249                                          return 659;
2250                                        }
2251                                      else
2252                                        {
2253                                          /* 33222222222211111111110000000000
2254                                             10987654321098765432109876543210
2255                                             xxxxxxxxxx1xxxxxxxxxxxx100011101
2256                                             ldrsw.  */
2257                                          return 667;
2258                                        }
2259                                    }
2260                                  else
2261                                    {
2262                                      /* 33222222222211111111110000000000
2263                                         10987654321098765432109876543210
2264                                         xxxxxxxxxx1xxxxxxxxxxxx10001111x
2265                                         ldrsh.  */
2266                                      return 664;
2267                                    }
2268                                }
2269                            }
2270                        }
2271                    }
2272                  else
2273                    {
2274                      if (((word >> 23) & 0x1) == 0)
2275                        {
2276                          if (((word >> 22) & 0x1) == 0)
2277                            {
2278                              if (((word >> 31) & 0x1) == 0)
2279                                {
2280                                  if (((word >> 30) & 0x1) == 0)
2281                                    {
2282                                      /* 33222222222211111111110000000000
2283                                         10987654321098765432109876543210
2284                                         xxxxxxxxxxxxxxxxxxxxxx0010011x00
2285                                         strb.  */
2286                                      return 668;
2287                                    }
2288                                  else
2289                                    {
2290                                      /* 33222222222211111111110000000000
2291                                         10987654321098765432109876543210
2292                                         xxxxxxxxxxxxxxxxxxxxxx0010011x10
2293                                         strh.  */
2294                                      return 673;
2295                                    }
2296                                }
2297                              else
2298                                {
2299                                  /* 33222222222211111111110000000000
2300                                     10987654321098765432109876543210
2301                                     xxxxxxxxxxxxxxxxxxxxxx0010011xx1
2302                                     str.  */
2303                                  return 676;
2304                                }
2305                            }
2306                          else
2307                            {
2308                              if (((word >> 31) & 0x1) == 0)
2309                                {
2310                                  if (((word >> 30) & 0x1) == 0)
2311                                    {
2312                                      /* 33222222222211111111110000000000
2313                                         10987654321098765432109876543210
2314                                         xxxxxxxxxxxxxxxxxxxxxx1010011x00
2315                                         ldrb.  */
2316                                      return 669;
2317                                    }
2318                                  else
2319                                    {
2320                                      /* 33222222222211111111110000000000
2321                                         10987654321098765432109876543210
2322                                         xxxxxxxxxxxxxxxxxxxxxx1010011x10
2323                                         ldrh.  */
2324                                      return 674;
2325                                    }
2326                                }
2327                              else
2328                                {
2329                                  /* 33222222222211111111110000000000
2330                                     10987654321098765432109876543210
2331                                     xxxxxxxxxxxxxxxxxxxxxx1010011xx1
2332                                     ldr.  */
2333                                  return 677;
2334                                }
2335                            }
2336                        }
2337                      else
2338                        {
2339                          if (((word >> 30) & 0x1) == 0)
2340                            {
2341                              if (((word >> 31) & 0x1) == 0)
2342                                {
2343                                  /* 33222222222211111111110000000000
2344                                     10987654321098765432109876543210
2345                                     xxxxxxxxxxxxxxxxxxxxxxx110011x00
2346                                     ldrsb.  */
2347                                  return 670;
2348                                }
2349                              else
2350                                {
2351                                  /* 33222222222211111111110000000000
2352                                     10987654321098765432109876543210
2353                                     xxxxxxxxxxxxxxxxxxxxxxx110011x01
2354                                     ldrsw.  */
2355                                  return 678;
2356                                }
2357                            }
2358                          else
2359                            {
2360                              if (((word >> 31) & 0x1) == 0)
2361                                {
2362                                  /* 33222222222211111111110000000000
2363                                     10987654321098765432109876543210
2364                                     xxxxxxxxxxxxxxxxxxxxxxx110011x10
2365                                     ldrsh.  */
2366                                  return 675;
2367                                }
2368                              else
2369                                {
2370                                  /* 33222222222211111111110000000000
2371                                     10987654321098765432109876543210
2372                                     xxxxxxxxxxxxxxxxxxxxxxx110011x11
2373                                     prfm.  */
2374                                  return 679;
2375                                }
2376                            }
2377                        }
2378                    }
2379                }
2380            }
2381        }
2382      else
2383        {
2384          if (((word >> 24) & 0x1) == 0)
2385            {
2386              if (((word >> 27) & 0x1) == 0)
2387                {
2388                  if (((word >> 23) & 0x1) == 0)
2389                    {
2390                      if (((word >> 29) & 0x1) == 0)
2391                        {
2392                          if (((word >> 30) & 0x1) == 0)
2393                            {
2394                              /* 33222222222211111111110000000000
2395                                 10987654321098765432109876543210
2396                                 xxxxxxxxxxxxxxxxxxxxxxx00100x00x
2397                                 and.  */
2398                              return 759;
2399                            }
2400                          else
2401                            {
2402                              /* 33222222222211111111110000000000
2403                                 10987654321098765432109876543210
2404                                 xxxxxxxxxxxxxxxxxxxxxxx00100x01x
2405                                 eor.  */
2406                              return 763;
2407                            }
2408                        }
2409                      else
2410                        {
2411                          if (((word >> 30) & 0x1) == 0)
2412                            {
2413                              /* 33222222222211111111110000000000
2414                                 10987654321098765432109876543210
2415                                 xxxxxxxxxxxxxxxxxxxxxxx00100x10x
2416                                 orr.  */
2417                              return 761;
2418                            }
2419                          else
2420                            {
2421                              /* 33222222222211111111110000000000
2422                                 10987654321098765432109876543210
2423                                 xxxxxxxxxxxxxxxxxxxxxxx00100x11x
2424                                 ands.  */
2425                              return 764;
2426                            }
2427                        }
2428                    }
2429                  else
2430                    {
2431                      if (((word >> 29) & 0x1) == 0)
2432                        {
2433                          if (((word >> 30) & 0x1) == 0)
2434                            {
2435                              /* 33222222222211111111110000000000
2436                                 10987654321098765432109876543210
2437                                 xxxxxxxxxxxxxxxxxxxxxxx10100x00x
2438                                 movn.  */
2439                              return 950;
2440                            }
2441                          else
2442                            {
2443                              /* 33222222222211111111110000000000
2444                                 10987654321098765432109876543210
2445                                 xxxxxxxxxxxxxxxxxxxxxxx10100x01x
2446                                 movz.  */
2447                              return 952;
2448                            }
2449                        }
2450                      else
2451                        {
2452                          /* 33222222222211111111110000000000
2453                             10987654321098765432109876543210
2454                             xxxxxxxxxxxxxxxxxxxxxxx10100x1xx
2455                             movk.  */
2456                          return 954;
2457                        }
2458                    }
2459                }
2460              else
2461                {
2462                  if (((word >> 21) & 0x1) == 0)
2463                    {
2464                      if (((word >> 28) & 0x1) == 0)
2465                        {
2466                          if (((word >> 29) & 0x1) == 0)
2467                            {
2468                              if (((word >> 30) & 0x1) == 0)
2469                                {
2470                                  /* 33222222222211111111110000000000
2471                                     10987654321098765432109876543210
2472                                     xxxxxxxxxxxxxxxxxxxxx0xx0101000x
2473                                     and.  */
2474                                  return 766;
2475                                }
2476                              else
2477                                {
2478                                  /* 33222222222211111111110000000000
2479                                     10987654321098765432109876543210
2480                                     xxxxxxxxxxxxxxxxxxxxx0xx0101001x
2481                                     eor.  */
2482                                  return 773;
2483                                }
2484                            }
2485                          else
2486                            {
2487                              if (((word >> 30) & 0x1) == 0)
2488                                {
2489                                  /* 33222222222211111111110000000000
2490                                     10987654321098765432109876543210
2491                                     xxxxxxxxxxxxxxxxxxxxx0xx0101010x
2492                                     orr.  */
2493                                  return 768;
2494                                }
2495                              else
2496                                {
2497                                  /* 33222222222211111111110000000000
2498                                     10987654321098765432109876543210
2499                                     xxxxxxxxxxxxxxxxxxxxx0xx0101011x
2500                                     ands.  */
2501                                  return 775;
2502                                }
2503                            }
2504                        }
2505                      else
2506                        {
2507                          if (((word >> 10) & 0x1) == 0)
2508                            {
2509                              if (((word >> 11) & 0x1) == 0)
2510                                {
2511                                  if (((word >> 22) & 0x1) == 0)
2512                                    {
2513                                      if (((word >> 23) & 0x1) == 0)
2514                                        {
2515                                          if (((word >> 29) & 0x1) == 0)
2516                                            {
2517                                              if (((word >> 30) & 0x1) == 0)
2518                                                {
2519                                                  /* 33222222222211111111110000000000
2520                                                     10987654321098765432109876543210
2521                                                     xxxxxxxxxx00xxxxxxxxx0000101100x
2522                                                     adc.  */
2523                                                  return 0;
2524                                                }
2525                                              else
2526                                                {
2527                                                  /* 33222222222211111111110000000000
2528                                                     10987654321098765432109876543210
2529                                                     xxxxxxxxxx00xxxxxxxxx0000101101x
2530                                                     sbc.  */
2531                                                  return 2;
2532                                                }
2533                                            }
2534                                          else
2535                                            {
2536                                              if (((word >> 30) & 0x1) == 0)
2537                                                {
2538                                                  /* 33222222222211111111110000000000
2539                                                     10987654321098765432109876543210
2540                                                     xxxxxxxxxx00xxxxxxxxx0000101110x
2541                                                     adcs.  */
2542                                                  return 1;
2543                                                }
2544                                              else
2545                                                {
2546                                                  /* 33222222222211111111110000000000
2547                                                     10987654321098765432109876543210
2548                                                     xxxxxxxxxx00xxxxxxxxx0000101111x
2549                                                     sbcs.  */
2550                                                  return 4;
2551                                                }
2552                                            }
2553                                        }
2554                                      else
2555                                        {
2556                                          if (((word >> 30) & 0x1) == 0)
2557                                            {
2558                                              /* 33222222222211111111110000000000
2559                                                 10987654321098765432109876543210
2560                                                 xxxxxxxxxx00xxxxxxxxx00101011x0x
2561                                                 csel.  */
2562                                              return 532;
2563                                            }
2564                                          else
2565                                            {
2566                                              /* 33222222222211111111110000000000
2567                                                 10987654321098765432109876543210
2568                                                 xxxxxxxxxx00xxxxxxxxx00101011x1x
2569                                                 csinv.  */
2570                                              return 536;
2571                                            }
2572                                        }
2573                                    }
2574                                  else
2575                                    {
2576                                      if (((word >> 23) & 0x1) == 0)
2577                                        {
2578                                          if (((word >> 30) & 0x1) == 0)
2579                                            {
2580                                              /* 33222222222211111111110000000000
2581                                                 10987654321098765432109876543210
2582                                                 xxxxxxxxxx00xxxxxxxxx01001011x0x
2583                                                 ccmn.  */
2584                                              return 530;
2585                                            }
2586                                          else
2587                                            {
2588                                              /* 33222222222211111111110000000000
2589                                                 10987654321098765432109876543210
2590                                                 xxxxxxxxxx00xxxxxxxxx01001011x1x
2591                                                 ccmp.  */
2592                                              return 531;
2593                                            }
2594                                        }
2595                                      else
2596                                        {
2597                                          if (((word >> 12) & 0x1) == 0)
2598                                            {
2599                                              if (((word >> 13) & 0x1) == 0)
2600                                                {
2601                                                  if (((word >> 14) & 0x1) == 0)
2602                                                    {
2603                                                      /* 33222222222211111111110000000000
2604                                                         10987654321098765432109876543210
2605                                                         xxxxxxxxxx00000xxxxxx01101011xxx
2606                                                         rbit.  */
2607                                                      return 555;
2608                                                    }
2609                                                  else
2610                                                    {
2611                                                      /* 33222222222211111111110000000000
2612                                                         10987654321098765432109876543210
2613                                                         xxxxxxxxxx00001xxxxxx01101011xxx
2614                                                         crc32b.  */
2615                                                      return 572;
2616                                                    }
2617                                                }
2618                                              else
2619                                                {
2620                                                  /* 33222222222211111111110000000000
2621                                                     10987654321098765432109876543210
2622                                                     xxxxxxxxxx0001xxxxxxx01101011xxx
2623                                                     lslv.  */
2624                                                  return 564;
2625                                                }
2626                                            }
2627                                          else
2628                                            {
2629                                              if (((word >> 14) & 0x1) == 0)
2630                                                {
2631                                                  /* 33222222222211111111110000000000
2632                                                     10987654321098765432109876543210
2633                                                     xxxxxxxxxx001x0xxxxxx01101011xxx
2634                                                     clz.  */
2635                                                  return 559;
2636                                                }
2637                                              else
2638                                                {
2639                                                  /* 33222222222211111111110000000000
2640                                                     10987654321098765432109876543210
2641                                                     xxxxxxxxxx001x1xxxxxx01101011xxx
2642                                                     crc32cb.  */
2643                                                  return 576;
2644                                                }
2645                                            }
2646                                        }
2647                                    }
2648                                }
2649                              else
2650                                {
2651                                  if (((word >> 23) & 0x1) == 0)
2652                                    {
2653                                      if (((word >> 30) & 0x1) == 0)
2654                                        {
2655                                          /* 33222222222211111111110000000000
2656                                             10987654321098765432109876543210
2657                                             xxxxxxxxxx01xxxxxxxxx0x001011x0x
2658                                             ccmn.  */
2659                                          return 528;
2660                                        }
2661                                      else
2662                                        {
2663                                          /* 33222222222211111111110000000000
2664                                             10987654321098765432109876543210
2665                                             xxxxxxxxxx01xxxxxxxxx0x001011x1x
2666                                             ccmp.  */
2667                                          return 529;
2668                                        }
2669                                    }
2670                                  else
2671                                    {
2672                                      if (((word >> 12) & 0x1) == 0)
2673                                        {
2674                                          if (((word >> 13) & 0x1) == 0)
2675                                            {
2676                                              if (((word >> 14) & 0x1) == 0)
2677                                                {
2678                                                  if (((word >> 30) & 0x1) == 0)
2679                                                    {
2680                                                      /* 33222222222211111111110000000000
2681                                                         10987654321098765432109876543210
2682                                                         xxxxxxxxxx01000xxxxxx0x101011x0x
2683                                                         udiv.  */
2684                                                      return 562;
2685                                                    }
2686                                                  else
2687                                                    {
2688                                                      if (((word >> 31) & 0x1) == 0)
2689                                                        {
2690                                                          /* 33222222222211111111110000000000
2691                                                             10987654321098765432109876543210
2692                                                             xxxxxxxxxx01000xxxxxx0x101011x10
2693                                                             rev.  */
2694                                                          return 557;
2695                                                        }
2696                                                      else
2697                                                        {
2698                                                          /* 33222222222211111111110000000000
2699                                                             10987654321098765432109876543210
2700                                                             xxxxxxxxxx01000xxxxxx0x101011x11
2701                                                             rev32.  */
2702                                                          return 561;
2703                                                        }
2704                                                    }
2705                                                }
2706                                              else
2707                                                {
2708                                                  /* 33222222222211111111110000000000
2709                                                     10987654321098765432109876543210
2710                                                     xxxxxxxxxx01001xxxxxx0x101011xxx
2711                                                     crc32w.  */
2712                                                  return 574;
2713                                                }
2714                                            }
2715                                          else
2716                                            {
2717                                              /* 33222222222211111111110000000000
2718                                                 10987654321098765432109876543210
2719                                                 xxxxxxxxxx0101xxxxxxx0x101011xxx
2720                                                 asrv.  */
2721                                              return 568;
2722                                            }
2723                                        }
2724                                      else
2725                                        {
2726                                          /* 33222222222211111111110000000000
2727                                             10987654321098765432109876543210
2728                                             xxxxxxxxxx011xxxxxxxx0x101011xxx
2729                                             crc32cw.  */
2730                                          return 578;
2731                                        }
2732                                    }
2733                                }
2734                            }
2735                          else
2736                            {
2737                              if (((word >> 11) & 0x1) == 0)
2738                                {
2739                                  if (((word >> 22) & 0x1) == 0)
2740                                    {
2741                                      if (((word >> 30) & 0x1) == 0)
2742                                        {
2743                                          /* 33222222222211111111110000000000
2744                                             10987654321098765432109876543210
2745                                             xxxxxxxxxx10xxxxxxxxx00x01011x0x
2746                                             csinc.  */
2747                                          return 533;
2748                                        }
2749                                      else
2750                                        {
2751                                          /* 33222222222211111111110000000000
2752                                             10987654321098765432109876543210
2753                                             xxxxxxxxxx10xxxxxxxxx00x01011x1x
2754                                             csneg.  */
2755                                          return 539;
2756                                        }
2757                                    }
2758                                  else
2759                                    {
2760                                      if (((word >> 12) & 0x1) == 0)
2761                                        {
2762                                          if (((word >> 13) & 0x1) == 0)
2763                                            {
2764                                              if (((word >> 14) & 0x1) == 0)
2765                                                {
2766                                                  /* 33222222222211111111110000000000
2767                                                     10987654321098765432109876543210
2768                                                     xxxxxxxxxx10000xxxxxx01x01011xxx
2769                                                     rev16.  */
2770                                                  return 556;
2771                                                }
2772                                              else
2773                                                {
2774                                                  /* 33222222222211111111110000000000
2775                                                     10987654321098765432109876543210
2776                                                     xxxxxxxxxx10001xxxxxx01x01011xxx
2777                                                     crc32h.  */
2778                                                  return 573;
2779                                                }
2780                                            }
2781                                          else
2782                                            {
2783                                              /* 33222222222211111111110000000000
2784                                                 10987654321098765432109876543210
2785                                                 xxxxxxxxxx1001xxxxxxx01x01011xxx
2786                                                 lsrv.  */
2787                                              return 566;
2788                                            }
2789                                        }
2790                                      else
2791                                        {
2792                                          if (((word >> 14) & 0x1) == 0)
2793                                            {
2794                                              /* 33222222222211111111110000000000
2795                                                 10987654321098765432109876543210
2796                                                 xxxxxxxxxx101x0xxxxxx01x01011xxx
2797                                                 cls.  */
2798                                              return 560;
2799                                            }
2800                                          else
2801                                            {
2802                                              /* 33222222222211111111110000000000
2803                                                 10987654321098765432109876543210
2804                                                 xxxxxxxxxx101x1xxxxxx01x01011xxx
2805                                                 crc32ch.  */
2806                                              return 577;
2807                                            }
2808                                        }
2809                                    }
2810                                }
2811                              else
2812                                {
2813                                  if (((word >> 12) & 0x1) == 0)
2814                                    {
2815                                      if (((word >> 13) & 0x1) == 0)
2816                                        {
2817                                          if (((word >> 14) & 0x1) == 0)
2818                                            {
2819                                              if (((word >> 30) & 0x1) == 0)
2820                                                {
2821                                                  /* 33222222222211111111110000000000
2822                                                     10987654321098765432109876543210
2823                                                     xxxxxxxxxx11000xxxxxx0xx01011x0x
2824                                                     sdiv.  */
2825                                                  return 563;
2826                                                }
2827                                              else
2828                                                {
2829                                                  /* 33222222222211111111110000000000
2830                                                     10987654321098765432109876543210
2831                                                     xxxxxxxxxx11000xxxxxx0xx01011x1x
2832                                                     rev.  */
2833                                                  return 558;
2834                                                }
2835                                            }
2836                                          else
2837                                            {
2838                                              /* 33222222222211111111110000000000
2839                                                 10987654321098765432109876543210
2840                                                 xxxxxxxxxx11001xxxxxx0xx01011xxx
2841                                                 crc32x.  */
2842                                              return 575;
2843                                            }
2844                                        }
2845                                      else
2846                                        {
2847                                          /* 33222222222211111111110000000000
2848                                             10987654321098765432109876543210
2849                                             xxxxxxxxxx1101xxxxxxx0xx01011xxx
2850                                             rorv.  */
2851                                          return 570;
2852                                        }
2853                                    }
2854                                  else
2855                                    {
2856                                      /* 33222222222211111111110000000000
2857                                         10987654321098765432109876543210
2858                                         xxxxxxxxxx111xxxxxxxx0xx01011xxx
2859                                         crc32cx.  */
2860                                      return 579;
2861                                    }
2862                                }
2863                            }
2864                        }
2865                    }
2866                  else
2867                    {
2868                      if (((word >> 29) & 0x1) == 0)
2869                        {
2870                          if (((word >> 30) & 0x1) == 0)
2871                            {
2872                              /* 33222222222211111111110000000000
2873                                 10987654321098765432109876543210
2874                                 xxxxxxxxxxxxxxxxxxxxx1xx0101x00x
2875                                 bic.  */
2876                              return 767;
2877                            }
2878                          else
2879                            {
2880                              /* 33222222222211111111110000000000
2881                                 10987654321098765432109876543210
2882                                 xxxxxxxxxxxxxxxxxxxxx1xx0101x01x
2883                                 eon.  */
2884                              return 774;
2885                            }
2886                        }
2887                      else
2888                        {
2889                          if (((word >> 30) & 0x1) == 0)
2890                            {
2891                              /* 33222222222211111111110000000000
2892                                 10987654321098765432109876543210
2893                                 xxxxxxxxxxxxxxxxxxxxx1xx0101x10x
2894                                 orn.  */
2895                              return 771;
2896                            }
2897                          else
2898                            {
2899                              /* 33222222222211111111110000000000
2900                                 10987654321098765432109876543210
2901                                 xxxxxxxxxxxxxxxxxxxxx1xx0101x11x
2902                                 bics.  */
2903                              return 777;
2904                            }
2905                        }
2906                    }
2907                }
2908            }
2909          else
2910            {
2911              if (((word >> 27) & 0x1) == 0)
2912                {
2913                  if (((word >> 23) & 0x1) == 0)
2914                    {
2915                      if (((word >> 29) & 0x1) == 0)
2916                        {
2917                          if (((word >> 30) & 0x1) == 0)
2918                            {
2919                              /* 33222222222211111111110000000000
2920                                 10987654321098765432109876543210
2921                                 xxxxxxxxxxxxxxxxxxxxxxx01100x00x
2922                                 sbfm.  */
2923                              return 501;
2924                            }
2925                          else
2926                            {
2927                              /* 33222222222211111111110000000000
2928                                 10987654321098765432109876543210
2929                                 xxxxxxxxxxxxxxxxxxxxxxx01100x01x
2930                                 ubfm.  */
2931                              return 511;
2932                            }
2933                        }
2934                      else
2935                        {
2936                          /* 33222222222211111111110000000000
2937                             10987654321098765432109876543210
2938                             xxxxxxxxxxxxxxxxxxxxxxx01100x1xx
2939                             bfm.  */
2940                          return 508;
2941                        }
2942                    }
2943                  else
2944                    {
2945                      /* 33222222222211111111110000000000
2946                         10987654321098765432109876543210
2947                         xxxxxxxxxxxxxxxxxxxxxxx11100xxxx
2948                         extr.  */
2949                      return 602;
2950                    }
2951                }
2952              else
2953                {
2954                  if (((word >> 21) & 0x1) == 0)
2955                    {
2956                      if (((word >> 28) & 0x1) == 0)
2957                        {
2958                          if (((word >> 29) & 0x1) == 0)
2959                            {
2960                              if (((word >> 30) & 0x1) == 0)
2961                                {
2962                                  /* 33222222222211111111110000000000
2963                                     10987654321098765432109876543210
2964                                     xxxxxxxxxxxxxxxxxxxxx0xx1101000x
2965                                     add.  */
2966                                  return 19;
2967                                }
2968                              else
2969                                {
2970                                  /* 33222222222211111111110000000000
2971                                     10987654321098765432109876543210
2972                                     xxxxxxxxxxxxxxxxxxxxx0xx1101001x
2973                                     sub.  */
2974                                  return 22;
2975                                }
2976                            }
2977                          else
2978                            {
2979                              if (((word >> 30) & 0x1) == 0)
2980                                {
2981                                  /* 33222222222211111111110000000000
2982                                     10987654321098765432109876543210
2983                                     xxxxxxxxxxxxxxxxxxxxx0xx1101010x
2984                                     adds.  */
2985                                  return 20;
2986                                }
2987                              else
2988                                {
2989                                  /* 33222222222211111111110000000000
2990                                     10987654321098765432109876543210
2991                                     xxxxxxxxxxxxxxxxxxxxx0xx1101011x
2992                                     subs.  */
2993                                  return 24;
2994                                }
2995                            }
2996                        }
2997                      else
2998                        {
2999                          if (((word >> 15) & 0x1) == 0)
3000                            {
3001                              if (((word >> 22) & 0x1) == 0)
3002                                {
3003                                  /* 33222222222211111111110000000000
3004                                     10987654321098765432109876543210
3005                                     xxxxxxxxxxxxxxx0xxxxx00x11011xxx
3006                                     madd.  */
3007                                  return 580;
3008                                }
3009                              else
3010                                {
3011                                  if (((word >> 23) & 0x1) == 0)
3012                                    {
3013                                      /* 33222222222211111111110000000000
3014                                         10987654321098765432109876543210
3015                                         xxxxxxxxxxxxxxx0xxxxx01011011xxx
3016                                         smulh.  */
3017                                      return 588;
3018                                    }
3019                                  else
3020                                    {
3021                                      /* 33222222222211111111110000000000
3022                                         10987654321098765432109876543210
3023                                         xxxxxxxxxxxxxxx0xxxxx01111011xxx
3024                                         umulh.  */
3025                                      return 593;
3026                                    }
3027                                }
3028                            }
3029                          else
3030                            {
3031                              /* 33222222222211111111110000000000
3032                                 10987654321098765432109876543210
3033                                 xxxxxxxxxxxxxxx1xxxxx0xx11011xxx
3034                                 msub.  */
3035                              return 582;
3036                            }
3037                        }
3038                    }
3039                  else
3040                    {
3041                      if (((word >> 23) & 0x1) == 0)
3042                        {
3043                          if (((word >> 28) & 0x1) == 0)
3044                            {
3045                              if (((word >> 29) & 0x1) == 0)
3046                                {
3047                                  if (((word >> 30) & 0x1) == 0)
3048                                    {
3049                                      /* 33222222222211111111110000000000
3050                                         10987654321098765432109876543210
3051                                         xxxxxxxxxxxxxxxxxxxxx1x01101000x
3052                                         add.  */
3053                                      return 6;
3054                                    }
3055                                  else
3056                                    {
3057                                      /* 33222222222211111111110000000000
3058                                         10987654321098765432109876543210
3059                                         xxxxxxxxxxxxxxxxxxxxx1x01101001x
3060                                         sub.  */
3061                                      return 9;
3062                                    }
3063                                }
3064                              else
3065                                {
3066                                  if (((word >> 30) & 0x1) == 0)
3067                                    {
3068                                      /* 33222222222211111111110000000000
3069                                         10987654321098765432109876543210
3070                                         xxxxxxxxxxxxxxxxxxxxx1x01101010x
3071                                         adds.  */
3072                                      return 7;
3073                                    }
3074                                  else
3075                                    {
3076                                      /* 33222222222211111111110000000000
3077                                         10987654321098765432109876543210
3078                                         xxxxxxxxxxxxxxxxxxxxx1x01101011x
3079                                         subs.  */
3080                                      return 10;
3081                                    }
3082                                }
3083                            }
3084                          else
3085                            {
3086                              if (((word >> 15) & 0x1) == 0)
3087                                {
3088                                  /* 33222222222211111111110000000000
3089                                     10987654321098765432109876543210
3090                                     xxxxxxxxxxxxxxx0xxxxx1x011011xxx
3091                                     smaddl.  */
3092                                  return 584;
3093                                }
3094                              else
3095                                {
3096                                  /* 33222222222211111111110000000000
3097                                     10987654321098765432109876543210
3098                                     xxxxxxxxxxxxxxx1xxxxx1x011011xxx
3099                                     smsubl.  */
3100                                  return 586;
3101                                }
3102                            }
3103                        }
3104                      else
3105                        {
3106                          if (((word >> 15) & 0x1) == 0)
3107                            {
3108                              /* 33222222222211111111110000000000
3109                                 10987654321098765432109876543210
3110                                 xxxxxxxxxxxxxxx0xxxxx1x11101xxxx
3111                                 umaddl.  */
3112                              return 589;
3113                            }
3114                          else
3115                            {
3116                              /* 33222222222211111111110000000000
3117                                 10987654321098765432109876543210
3118                                 xxxxxxxxxxxxxxx1xxxxx1x11101xxxx
3119                                 umsubl.  */
3120                              return 591;
3121                            }
3122                        }
3123                    }
3124                }
3125            }
3126        }
3127    }
3128  else
3129    {
3130      if (((word >> 27) & 0x1) == 0)
3131        {
3132          if (((word >> 29) & 0x1) == 0)
3133            {
3134              if (((word >> 30) & 0x1) == 0)
3135                {
3136                  if (((word >> 31) & 0x1) == 0)
3137                    {
3138                      /* 33222222222211111111110000000000
3139                         10987654321098765432109876543210
3140                         xxxxxxxxxxxxxxxxxxxxxxxxxx10x000
3141                         b.  */
3142                      return 518;
3143                    }
3144                  else
3145                    {
3146                      /* 33222222222211111111110000000000
3147                         10987654321098765432109876543210
3148                         xxxxxxxxxxxxxxxxxxxxxxxxxx10x001
3149                         bl.  */
3150                      return 519;
3151                    }
3152                }
3153              else
3154                {
3155                  if (((word >> 24) & 0x1) == 0)
3156                    {
3157                      if (((word >> 25) & 0x1) == 0)
3158                        {
3159                          if (((word >> 31) & 0x1) == 0)
3160                            {
3161                              /* 33222222222211111111110000000000
3162                                 10987654321098765432109876543210
3163                                 xxxxxxxxxxxxxxxxxxxxxxxx0010x010
3164                                 b.c.  */
3165                              return 527;
3166                            }
3167                          else
3168                            {
3169                              if (((word >> 0) & 0x1) == 0)
3170                                {
3171                                  if (((word >> 1) & 0x1) == 0)
3172                                    {
3173                                      if (((word >> 21) & 0x1) == 0)
3174                                        {
3175                                          /* 33222222222211111111110000000000
3176                                             10987654321098765432109876543210
3177                                             00xxxxxxxxxxxxxxxxxxx0xx0010x011
3178                                             hlt.  */
3179                                          return 598;
3180                                        }
3181                                      else
3182                                        {
3183                                          /* 33222222222211111111110000000000
3184                                             10987654321098765432109876543210
3185                                             00xxxxxxxxxxxxxxxxxxx1xx0010x011
3186                                             brk.  */
3187                                          return 597;
3188                                        }
3189                                    }
3190                                  else
3191                                    {
3192                                      if (((word >> 21) & 0x1) == 0)
3193                                        {
3194                                          /* 33222222222211111111110000000000
3195                                             10987654321098765432109876543210
3196                                             01xxxxxxxxxxxxxxxxxxx0xx0010x011
3197                                             hvc.  */
3198                                          return 595;
3199                                        }
3200                                      else
3201                                        {
3202                                          /* 33222222222211111111110000000000
3203                                             10987654321098765432109876543210
3204                                             01xxxxxxxxxxxxxxxxxxx1xx0010x011
3205                                             dcps2.  */
3206                                          return 600;
3207                                        }
3208                                    }
3209                                }
3210                              else
3211                                {
3212                                  if (((word >> 1) & 0x1) == 0)
3213                                    {
3214                                      if (((word >> 21) & 0x1) == 0)
3215                                        {
3216                                          /* 33222222222211111111110000000000
3217                                             10987654321098765432109876543210
3218                                             10xxxxxxxxxxxxxxxxxxx0xx0010x011
3219                                             svc.  */
3220                                          return 594;
3221                                        }
3222                                      else
3223                                        {
3224                                          /* 33222222222211111111110000000000
3225                                             10987654321098765432109876543210
3226                                             10xxxxxxxxxxxxxxxxxxx1xx0010x011
3227                                             dcps1.  */
3228                                          return 599;
3229                                        }
3230                                    }
3231                                  else
3232                                    {
3233                                      if (((word >> 21) & 0x1) == 0)
3234                                        {
3235                                          /* 33222222222211111111110000000000
3236                                             10987654321098765432109876543210
3237                                             11xxxxxxxxxxxxxxxxxxx0xx0010x011
3238                                             smc.  */
3239                                          return 596;
3240                                        }
3241                                      else
3242                                        {
3243                                          /* 33222222222211111111110000000000
3244                                             10987654321098765432109876543210
3245                                             11xxxxxxxxxxxxxxxxxxx1xx0010x011
3246                                             dcps3.  */
3247                                          return 601;
3248                                        }
3249                                    }
3250                                }
3251                            }
3252                        }
3253                      else
3254                        {
3255                          if (((word >> 21) & 0x1) == 0)
3256                            {
3257                              if (((word >> 22) & 0x1) == 0)
3258                                {
3259                                  if (((word >> 23) & 0x1) == 0)
3260                                    {
3261                                      /* 33222222222211111111110000000000
3262                                         10987654321098765432109876543210
3263                                         xxxxxxxxxxxxxxxxxxxxx0000110x01x
3264                                         br.  */
3265                                      return 520;
3266                                    }
3267                                  else
3268                                    {
3269                                      /* 33222222222211111111110000000000
3270                                         10987654321098765432109876543210
3271                                         xxxxxxxxxxxxxxxxxxxxx0010110x01x
3272                                         eret.  */
3273                                      return 523;
3274                                    }
3275                                }
3276                              else
3277                                {
3278                                  /* 33222222222211111111110000000000
3279                                     10987654321098765432109876543210
3280                                     xxxxxxxxxxxxxxxxxxxxx01x0110x01x
3281                                     ret.  */
3282                                  return 522;
3283                                }
3284                            }
3285                          else
3286                            {
3287                              if (((word >> 23) & 0x1) == 0)
3288                                {
3289                                  /* 33222222222211111111110000000000
3290                                     10987654321098765432109876543210
3291                                     xxxxxxxxxxxxxxxxxxxxx1x00110x01x
3292                                     blr.  */
3293                                  return 521;
3294                                }
3295                              else
3296                                {
3297                                  /* 33222222222211111111110000000000
3298                                     10987654321098765432109876543210
3299                                     xxxxxxxxxxxxxxxxxxxxx1x10110x01x
3300                                     drps.  */
3301                                  return 524;
3302                                }
3303                            }
3304                        }
3305                    }
3306                  else
3307                    {
3308                      if (((word >> 21) & 0x1) == 0)
3309                        {
3310                          /* 33222222222211111111110000000000
3311                             10987654321098765432109876543210
3312                             xxxxxxxxxxxxxxxxxxxxx0xx1x10x01x
3313                             msr.  */
3314                          return 957;
3315                        }
3316                      else
3317                        {
3318                          /* 33222222222211111111110000000000
3319                             10987654321098765432109876543210
3320                             xxxxxxxxxxxxxxxxxxxxx1xx1x10x01x
3321                             sysl.  */
3322                          return 975;
3323                        }
3324                    }
3325                }
3326            }
3327          else
3328            {
3329              if (((word >> 24) & 0x1) == 0)
3330                {
3331                  if (((word >> 25) & 0x1) == 0)
3332                    {
3333                      /* 33222222222211111111110000000000
3334                         10987654321098765432109876543210
3335                         xxxxxxxxxxxxxxxxxxxxxxxx0010x1xx
3336                         cbz.  */
3337                      return 525;
3338                    }
3339                  else
3340                    {
3341                      /* 33222222222211111111110000000000
3342                         10987654321098765432109876543210
3343                         xxxxxxxxxxxxxxxxxxxxxxxx0110x1xx
3344                         tbz.  */
3345                      return 977;
3346                    }
3347                }
3348              else
3349                {
3350                  if (((word >> 25) & 0x1) == 0)
3351                    {
3352                      /* 33222222222211111111110000000000
3353                         10987654321098765432109876543210
3354                         xxxxxxxxxxxxxxxxxxxxxxxx1010x1xx
3355                         cbnz.  */
3356                      return 526;
3357                    }
3358                  else
3359                    {
3360                      /* 33222222222211111111110000000000
3361                         10987654321098765432109876543210
3362                         xxxxxxxxxxxxxxxxxxxxxxxx1110x1xx
3363                         tbnz.  */
3364                      return 978;
3365                    }
3366                }
3367            }
3368        }
3369      else
3370        {
3371          if (((word >> 25) & 0x1) == 0)
3372            {
3373              if (((word >> 28) & 0x1) == 0)
3374                {
3375                  if (((word >> 22) & 0x1) == 0)
3376                    {
3377                      if (((word >> 23) & 0x1) == 0)
3378                        {
3379                          if (((word >> 24) & 0x1) == 0)
3380                            {
3381                              if (((word >> 29) & 0x1) == 0)
3382                                {
3383                                  /* 33222222222211111111110000000000
3384                                     10987654321098765432109876543210
3385                                     xxxxxxxxxxxxxxxxxxxxxx00001100xx
3386                                     st4.  */
3387                                  return 361;
3388                                }
3389                              else
3390                                {
3391                                  /* 33222222222211111111110000000000
3392                                     10987654321098765432109876543210
3393                                     xxxxxxxxxxxxxxxxxxxxxx00001101xx
3394                                     stnp.  */
3395                                  return 743;
3396                                }
3397                            }
3398                          else
3399                            {
3400                              if (((word >> 29) & 0x1) == 0)
3401                                {
3402                                  if (((word >> 13) & 0x1) == 0)
3403                                    {
3404                                      if (((word >> 21) & 0x1) == 0)
3405                                        {
3406                                          /* 33222222222211111111110000000000
3407                                             10987654321098765432109876543210
3408                                             xxxxxxxxxxxxx0xxxxxxx000101100xx
3409                                             st1.  */
3410                                          return 377;
3411                                        }
3412                                      else
3413                                        {
3414                                          /* 33222222222211111111110000000000
3415                                             10987654321098765432109876543210
3416                                             xxxxxxxxxxxxx0xxxxxxx100101100xx
3417                                             st2.  */
3418                                          return 379;
3419                                        }
3420                                    }
3421                                  else
3422                                    {
3423                                      if (((word >> 21) & 0x1) == 0)
3424                                        {
3425                                          /* 33222222222211111111110000000000
3426                                             10987654321098765432109876543210
3427                                             xxxxxxxxxxxxx1xxxxxxx000101100xx
3428                                             st3.  */
3429                                          return 378;
3430                                        }
3431                                      else
3432                                        {
3433                                          /* 33222222222211111111110000000000
3434                                             10987654321098765432109876543210
3435                                             xxxxxxxxxxxxx1xxxxxxx100101100xx
3436                                             st4.  */
3437                                          return 380;
3438                                        }
3439                                    }
3440                                }
3441                              else
3442                                {
3443                                  /* 33222222222211111111110000000000
3444                                     10987654321098765432109876543210
3445                                     xxxxxxxxxxxxxxxxxxxxxx00101101xx
3446                                     stp.  */
3447                                  return 747;
3448                                }
3449                            }
3450                        }
3451                      else
3452                        {
3453                          if (((word >> 29) & 0x1) == 0)
3454                            {
3455                              if (((word >> 21) & 0x1) == 0)
3456                                {
3457                                  if (((word >> 24) & 0x1) == 0)
3458                                    {
3459                                      /* 33222222222211111111110000000000
3460                                         10987654321098765432109876543210
3461                                         xxxxxxxxxxxxxxxxxxxxx001001100xx
3462                                         st4.  */
3463                                      return 369;
3464                                    }
3465                                  else
3466                                    {
3467                                      if (((word >> 13) & 0x1) == 0)
3468                                        {
3469                                          /* 33222222222211111111110000000000
3470                                             10987654321098765432109876543210
3471                                             xxxxxxxxxxxxx0xxxxxxx001101100xx
3472                                             st1.  */
3473                                          return 389;
3474                                        }
3475                                      else
3476                                        {
3477                                          /* 33222222222211111111110000000000
3478                                             10987654321098765432109876543210
3479                                             xxxxxxxxxxxxx1xxxxxxx001101100xx
3480                                             st3.  */
3481                                          return 390;
3482                                        }
3483                                    }
3484                                }
3485                              else
3486                                {
3487                                  if (((word >> 13) & 0x1) == 0)
3488                                    {
3489                                      /* 33222222222211111111110000000000
3490                                         10987654321098765432109876543210
3491                                         xxxxxxxxxxxxx0xxxxxxx101x01100xx
3492                                         st2.  */
3493                                      return 391;
3494                                    }
3495                                  else
3496                                    {
3497                                      /* 33222222222211111111110000000000
3498                                         10987654321098765432109876543210
3499                                         xxxxxxxxxxxxx1xxxxxxx101x01100xx
3500                                         st4.  */
3501                                      return 392;
3502                                    }
3503                                }
3504                            }
3505                          else
3506                            {
3507                              /* 33222222222211111111110000000000
3508                                 10987654321098765432109876543210
3509                                 xxxxxxxxxxxxxxxxxxxxxx01x01101xx
3510                                 stp.  */
3511                              return 752;
3512                            }
3513                        }
3514                    }
3515                  else
3516                    {
3517                      if (((word >> 23) & 0x1) == 0)
3518                        {
3519                          if (((word >> 24) & 0x1) == 0)
3520                            {
3521                              if (((word >> 29) & 0x1) == 0)
3522                                {
3523                                  /* 33222222222211111111110000000000
3524                                     10987654321098765432109876543210
3525                                     xxxxxxxxxxxxxxxxxxxxxx10001100xx
3526                                     ld4.  */
3527                                  return 365;
3528                                }
3529                              else
3530                                {
3531                                  /* 33222222222211111111110000000000
3532                                     10987654321098765432109876543210
3533                                     xxxxxxxxxxxxxxxxxxxxxx10001101xx
3534                                     ldnp.  */
3535                                  return 744;
3536                                }
3537                            }
3538                          else
3539                            {
3540                              if (((word >> 29) & 0x1) == 0)
3541                                {
3542                                  if (((word >> 13) & 0x1) == 0)
3543                                    {
3544                                      if (((word >> 21) & 0x1) == 0)
3545                                        {
3546                                          /* 33222222222211111111110000000000
3547                                             10987654321098765432109876543210
3548                                             xxxxxxxxxxxxx0xxxxxxx010101100xx
3549                                             ld1.  */
3550                                          return 381;
3551                                        }
3552                                      else
3553                                        {
3554                                          /* 33222222222211111111110000000000
3555                                             10987654321098765432109876543210
3556                                             xxxxxxxxxxxxx0xxxxxxx110101100xx
3557                                             ld2.  */
3558                                          return 385;
3559                                        }
3560                                    }
3561                                  else
3562                                    {
3563                                      if (((word >> 21) & 0x1) == 0)
3564                                        {
3565                                          /* 33222222222211111111110000000000
3566                                             10987654321098765432109876543210
3567                                             xxxxxxxxxxxxx1xxxxxxx010101100xx
3568                                             ld3.  */
3569                                          return 382;
3570                                        }
3571                                      else
3572                                        {
3573                                          /* 33222222222211111111110000000000
3574                                             10987654321098765432109876543210
3575                                             xxxxxxxxxxxxx1xxxxxxx110101100xx
3576                                             ld4.  */
3577                                          return 386;
3578                                        }
3579                                    }
3580                                }
3581                              else
3582                                {
3583                                  /* 33222222222211111111110000000000
3584                                     10987654321098765432109876543210
3585                                     xxxxxxxxxxxxxxxxxxxxxx10101101xx
3586                                     ldp.  */
3587                                  return 748;
3588                                }
3589                            }
3590                        }
3591                      else
3592                        {
3593                          if (((word >> 29) & 0x1) == 0)
3594                            {
3595                              if (((word >> 21) & 0x1) == 0)
3596                                {
3597                                  if (((word >> 24) & 0x1) == 0)
3598                                    {
3599                                      /* 33222222222211111111110000000000
3600                                         10987654321098765432109876543210
3601                                         xxxxxxxxxxxxxxxxxxxxx011001100xx
3602                                         ld4.  */
3603                                      return 373;
3604                                    }
3605                                  else
3606                                    {
3607                                      if (((word >> 13) & 0x1) == 0)
3608                                        {
3609                                          /* 33222222222211111111110000000000
3610                                             10987654321098765432109876543210
3611                                             xxxxxxxxxxxxx0xxxxxxx011101100xx
3612                                             ld1.  */
3613                                          return 393;
3614                                        }
3615                                      else
3616                                        {
3617                                          /* 33222222222211111111110000000000
3618                                             10987654321098765432109876543210
3619                                             xxxxxxxxxxxxx1xxxxxxx011101100xx
3620                                             ld3.  */
3621                                          return 394;
3622                                        }
3623                                    }
3624                                }
3625                              else
3626                                {
3627                                  if (((word >> 13) & 0x1) == 0)
3628                                    {
3629                                      /* 33222222222211111111110000000000
3630                                         10987654321098765432109876543210
3631                                         xxxxxxxxxxxxx0xxxxxxx111x01100xx
3632                                         ld2.  */
3633                                      return 397;
3634                                    }
3635                                  else
3636                                    {
3637                                      /* 33222222222211111111110000000000
3638                                         10987654321098765432109876543210
3639                                         xxxxxxxxxxxxx1xxxxxxx111x01100xx
3640                                         ld4.  */
3641                                      return 398;
3642                                    }
3643                                }
3644                            }
3645                          else
3646                            {
3647                              /* 33222222222211111111110000000000
3648                                 10987654321098765432109876543210
3649                                 xxxxxxxxxxxxxxxxxxxxxx11x01101xx
3650                                 ldp.  */
3651                              return 753;
3652                            }
3653                        }
3654                    }
3655                }
3656              else
3657                {
3658                  if (((word >> 24) & 0x1) == 0)
3659                    {
3660                      if (((word >> 29) & 0x1) == 0)
3661                        {
3662                          /* 33222222222211111111110000000000
3663                             10987654321098765432109876543210
3664                             xxxxxxxxxxxxxxxxxxxxxxxx001110xx
3665                             ldr.  */
3666                          return 756;
3667                        }
3668                      else
3669                        {
3670                          if (((word >> 10) & 0x1) == 0)
3671                            {
3672                              if (((word >> 11) & 0x1) == 0)
3673                                {
3674                                  if (((word >> 22) & 0x1) == 0)
3675                                    {
3676                                      /* 33222222222211111111110000000000
3677                                         10987654321098765432109876543210
3678                                         xxxxxxxxxx00xxxxxxxxxx0x001111xx
3679                                         stur.  */
3680                                      return 704;
3681                                    }
3682                                  else
3683                                    {
3684                                      /* 33222222222211111111110000000000
3685                                         10987654321098765432109876543210
3686                                         xxxxxxxxxx00xxxxxxxxxx1x001111xx
3687                                         ldur.  */
3688                                      return 705;
3689                                    }
3690                                }
3691                              else
3692                                {
3693                                  if (((word >> 22) & 0x1) == 0)
3694                                    {
3695                                      /* 33222222222211111111110000000000
3696                                         10987654321098765432109876543210
3697                                         xxxxxxxxxx01xxxxxxxxxx0x001111xx
3698                                         str.  */
3699                                      return 683;
3700                                    }
3701                                  else
3702                                    {
3703                                      /* 33222222222211111111110000000000
3704                                         10987654321098765432109876543210
3705                                         xxxxxxxxxx01xxxxxxxxxx1x001111xx
3706                                         ldr.  */
3707                                      return 684;
3708                                    }
3709                                }
3710                            }
3711                          else
3712                            {
3713                              if (((word >> 22) & 0x1) == 0)
3714                                {
3715                                  /* 33222222222211111111110000000000
3716                                     10987654321098765432109876543210
3717                                     xxxxxxxxxx1xxxxxxxxxxx0x001111xx
3718                                     str.  */
3719                                  return 660;
3720                                }
3721                              else
3722                                {
3723                                  /* 33222222222211111111110000000000
3724                                     10987654321098765432109876543210
3725                                     xxxxxxxxxx1xxxxxxxxxxx1x001111xx
3726                                     ldr.  */
3727                                  return 661;
3728                                }
3729                            }
3730                        }
3731                    }
3732                  else
3733                    {
3734                      if (((word >> 22) & 0x1) == 0)
3735                        {
3736                          /* 33222222222211111111110000000000
3737                             10987654321098765432109876543210
3738                             xxxxxxxxxxxxxxxxxxxxxx0x10111xxx
3739                             str.  */
3740                          return 671;
3741                        }
3742                      else
3743                        {
3744                          /* 33222222222211111111110000000000
3745                             10987654321098765432109876543210
3746                             xxxxxxxxxxxxxxxxxxxxxx1x10111xxx
3747                             ldr.  */
3748                          return 672;
3749                        }
3750                    }
3751                }
3752            }
3753          else
3754            {
3755              if (((word >> 24) & 0x1) == 0)
3756                {
3757                  if (((word >> 21) & 0x1) == 0)
3758                    {
3759                      if (((word >> 28) & 0x1) == 0)
3760                        {
3761                          if (((word >> 10) & 0x1) == 0)
3762                            {
3763                              if (((word >> 29) & 0x1) == 0)
3764                                {
3765                                  if (((word >> 11) & 0x1) == 0)
3766                                    {
3767                                      if (((word >> 12) & 0x1) == 0)
3768                                        {
3769                                          /* 33222222222211111111110000000000
3770                                             10987654321098765432109876543210
3771                                             xxxxxxxxxx000xxxxxxxx0xx011100xx
3772                                             tbl.  */
3773                                          return 345;
3774                                        }
3775                                      else
3776                                        {
3777                                          /* 33222222222211111111110000000000
3778                                             10987654321098765432109876543210
3779                                             xxxxxxxxxx001xxxxxxxx0xx011100xx
3780                                             tbx.  */
3781                                          return 346;
3782                                        }
3783                                    }
3784                                  else
3785                                    {
3786                                      if (((word >> 12) & 0x1) == 0)
3787                                        {
3788                                          if (((word >> 14) & 0x1) == 0)
3789                                            {
3790                                              /* 33222222222211111111110000000000
3791                                                 10987654321098765432109876543210
3792                                                 xxxxxxxxxx010x0xxxxxx0xx011100xx
3793                                                 trn1.  */
3794                                              return 218;
3795                                            }
3796                                          else
3797                                            {
3798                                              /* 33222222222211111111110000000000
3799                                                 10987654321098765432109876543210
3800                                                 xxxxxxxxxx010x1xxxxxx0xx011100xx
3801                                                 trn2.  */
3802                                              return 221;
3803                                            }
3804                                        }
3805                                      else
3806                                        {
3807                                          if (((word >> 13) & 0x1) == 0)
3808                                            {
3809                                              if (((word >> 14) & 0x1) == 0)
3810                                                {
3811                                                  /* 33222222222211111111110000000000
3812                                                     10987654321098765432109876543210
3813                                                     xxxxxxxxxx01100xxxxxx0xx011100xx
3814                                                     uzp1.  */
3815                                                  return 217;
3816                                                }
3817                                              else
3818                                                {
3819                                                  /* 33222222222211111111110000000000
3820                                                     10987654321098765432109876543210
3821                                                     xxxxxxxxxx01101xxxxxx0xx011100xx
3822                                                     uzp2.  */
3823                                                  return 220;
3824                                                }
3825                                            }
3826                                          else
3827                                            {
3828                                              if (((word >> 14) & 0x1) == 0)
3829                                                {
3830                                                  /* 33222222222211111111110000000000
3831                                                     10987654321098765432109876543210
3832                                                     xxxxxxxxxx01110xxxxxx0xx011100xx
3833                                                     zip1.  */
3834                                                  return 219;
3835                                                }
3836                                              else
3837                                                {
3838                                                  /* 33222222222211111111110000000000
3839                                                     10987654321098765432109876543210
3840                                                     xxxxxxxxxx01111xxxxxx0xx011100xx
3841                                                     zip2.  */
3842                                                  return 222;
3843                                                }
3844                                            }
3845                                        }
3846                                    }
3847                                }
3848                              else
3849                                {
3850                                  /* 33222222222211111111110000000000
3851                                     10987654321098765432109876543210
3852                                     xxxxxxxxxx0xxxxxxxxxx0xx011101xx
3853                                     ext.  */
3854                                  return 121;
3855                                }
3856                            }
3857                          else
3858                            {
3859                              if (((word >> 15) & 0x1) == 0)
3860                                {
3861                                  if (((word >> 29) & 0x1) == 0)
3862                                    {
3863                                      if (((word >> 11) & 0x1) == 0)
3864                                        {
3865                                          /* 33222222222211111111110000000000
3866                                             10987654321098765432109876543210
3867                                             xxxxxxxxxx10xxx0xxxxx0xx011100xx
3868                                             dup.  */
3869                                          return 137;
3870                                        }
3871                                      else
3872                                        {
3873                                          if (((word >> 12) & 0x1) == 0)
3874                                            {
3875                                              if (((word >> 13) & 0x1) == 0)
3876                                                {
3877                                                  /* 33222222222211111111110000000000
3878                                                     10987654321098765432109876543210
3879                                                     xxxxxxxxxx1100x0xxxxx0xx011100xx
3880                                                     dup.  */
3881                                                  return 138;
3882                                                }
3883                                              else
3884                                                {
3885                                                  /* 33222222222211111111110000000000
3886                                                     10987654321098765432109876543210
3887                                                     xxxxxxxxxx1101x0xxxxx0xx011100xx
3888                                                     smov.  */
3889                                                  return 139;
3890                                                }
3891                                            }
3892                                          else
3893                                            {
3894                                              if (((word >> 13) & 0x1) == 0)
3895                                                {
3896                                                  /* 33222222222211111111110000000000
3897                                                     10987654321098765432109876543210
3898                                                     xxxxxxxxxx1110x0xxxxx0xx011100xx
3899                                                     ins.  */
3900                                                  return 142;
3901                                                }
3902                                              else
3903                                                {
3904                                                  /* 33222222222211111111110000000000
3905                                                     10987654321098765432109876543210
3906                                                     xxxxxxxxxx1111x0xxxxx0xx011100xx
3907                                                     umov.  */
3908                                                  return 140;
3909                                                }
3910                                            }
3911                                        }
3912                                    }
3913                                  else
3914                                    {
3915                                      /* 33222222222211111111110000000000
3916                                         10987654321098765432109876543210
3917                                         xxxxxxxxxx1xxxx0xxxxx0xx011101xx
3918                                         ins.  */
3919                                      return 144;
3920                                    }
3921                                }
3922                              else
3923                                {
3924                                  if (((word >> 11) & 0x1) == 0)
3925                                    {
3926                                      /* 33222222222211111111110000000000
3927                                         10987654321098765432109876543210
3928                                         xxxxxxxxxx10xxx1xxxxx0xx01110xxx
3929                                         sqrdmlah.  */
3930                                      return 301;
3931                                    }
3932                                  else
3933                                    {
3934                                      /* 33222222222211111111110000000000
3935                                         10987654321098765432109876543210
3936                                         xxxxxxxxxx11xxx1xxxxx0xx01110xxx
3937                                         sqrdmlsh.  */
3938                                      return 302;
3939                                    }
3940                                }
3941                            }
3942                        }
3943                      else
3944                        {
3945                          if (((word >> 29) & 0x1) == 0)
3946                            {
3947                              if (((word >> 30) & 0x1) == 0)
3948                                {
3949                                  if (((word >> 16) & 0x1) == 0)
3950                                    {
3951                                      if (((word >> 17) & 0x1) == 0)
3952                                        {
3953                                          /* 33222222222211111111110000000000
3954                                             10987654321098765432109876543210
3955                                             xxxxxxxxxxxxxxxx00xxx0xx0111100x
3956                                             fcvtzs.  */
3957                                          return 606;
3958                                        }
3959                                      else
3960                                        {
3961                                          /* 33222222222211111111110000000000
3962                                             10987654321098765432109876543210
3963                                             xxxxxxxxxxxxxxxx01xxx0xx0111100x
3964                                             scvtf.  */
3965                                          return 604;
3966                                        }
3967                                    }
3968                                  else
3969                                    {
3970                                      if (((word >> 17) & 0x1) == 0)
3971                                        {
3972                                          /* 33222222222211111111110000000000
3973                                             10987654321098765432109876543210
3974                                             xxxxxxxxxxxxxxxx10xxx0xx0111100x
3975                                             fcvtzu.  */
3976                                          return 607;
3977                                        }
3978                                      else
3979                                        {
3980                                          /* 33222222222211111111110000000000
3981                                             10987654321098765432109876543210
3982                                             xxxxxxxxxxxxxxxx11xxx0xx0111100x
3983                                             ucvtf.  */
3984                                          return 605;
3985                                        }
3986                                    }
3987                                }
3988                              else
3989                                {
3990                                  if (((word >> 10) & 0x1) == 0)
3991                                    {
3992                                      if (((word >> 12) & 0x1) == 0)
3993                                        {
3994                                          if (((word >> 13) & 0x1) == 0)
3995                                            {
3996                                              if (((word >> 14) & 0x1) == 0)
3997                                                {
3998                                                  /* 33222222222211111111110000000000
3999                                                     10987654321098765432109876543210
4000                                                     xxxxxxxxxx0x000xxxxxx0xx0111101x
4001                                                     sha1c.  */
4002                                                  return 548;
4003                                                }
4004                                              else
4005                                                {
4006                                                  /* 33222222222211111111110000000000
4007                                                     10987654321098765432109876543210
4008                                                     xxxxxxxxxx0x001xxxxxx0xx0111101x
4009                                                     sha256h.  */
4010                                                  return 552;
4011                                                }
4012                                            }
4013                                          else
4014                                            {
4015                                              if (((word >> 14) & 0x1) == 0)
4016                                                {
4017                                                  /* 33222222222211111111110000000000
4018                                                     10987654321098765432109876543210
4019                                                     xxxxxxxxxx0x010xxxxxx0xx0111101x
4020                                                     sha1m.  */
4021                                                  return 550;
4022                                                }
4023                                              else
4024                                                {
4025                                                  /* 33222222222211111111110000000000
4026                                                     10987654321098765432109876543210
4027                                                     xxxxxxxxxx0x011xxxxxx0xx0111101x
4028                                                     sha256su1.  */
4029                                                  return 554;
4030                                                }
4031                                            }
4032                                        }
4033                                      else
4034                                        {
4035                                          if (((word >> 13) & 0x1) == 0)
4036                                            {
4037                                              if (((word >> 14) & 0x1) == 0)
4038                                                {
4039                                                  /* 33222222222211111111110000000000
4040                                                     10987654321098765432109876543210
4041                                                     xxxxxxxxxx0x100xxxxxx0xx0111101x
4042                                                     sha1p.  */
4043                                                  return 549;
4044                                                }
4045                                              else
4046                                                {
4047                                                  /* 33222222222211111111110000000000
4048                                                     10987654321098765432109876543210
4049                                                     xxxxxxxxxx0x101xxxxxx0xx0111101x
4050                                                     sha256h2.  */
4051                                                  return 553;
4052                                                }
4053                                            }
4054                                          else
4055                                            {
4056                                              /* 33222222222211111111110000000000
4057                                                 10987654321098765432109876543210
4058                                                 xxxxxxxxxx0x11xxxxxxx0xx0111101x
4059                                                 sha1su0.  */
4060                                              return 551;
4061                                            }
4062                                        }
4063                                    }
4064                                  else
4065                                    {
4066                                      /* 33222222222211111111110000000000
4067                                         10987654321098765432109876543210
4068                                         xxxxxxxxxx1xxxxxxxxxx0xx0111101x
4069                                         dup.  */
4070                                      return 436;
4071                                    }
4072                                }
4073                            }
4074                          else
4075                            {
4076                              if (((word >> 11) & 0x1) == 0)
4077                                {
4078                                  /* 33222222222211111111110000000000
4079                                     10987654321098765432109876543210
4080                                     xxxxxxxxxxx0xxxxxxxxx0xx011111xx
4081                                     sqrdmlah.  */
4082                                  return 475;
4083                                }
4084                              else
4085                                {
4086                                  /* 33222222222211111111110000000000
4087                                     10987654321098765432109876543210
4088                                     xxxxxxxxxxx1xxxxxxxxx0xx011111xx
4089                                     sqrdmlsh.  */
4090                                  return 476;
4091                                }
4092                            }
4093                        }
4094                    }
4095                  else
4096                    {
4097                      if (((word >> 10) & 0x1) == 0)
4098                        {
4099                          if (((word >> 11) & 0x1) == 0)
4100                            {
4101                              if (((word >> 12) & 0x1) == 0)
4102                                {
4103                                  if (((word >> 13) & 0x1) == 0)
4104                                    {
4105                                      if (((word >> 14) & 0x1) == 0)
4106                                        {
4107                                          if (((word >> 15) & 0x1) == 0)
4108                                            {
4109                                              if (((word >> 28) & 0x1) == 0)
4110                                                {
4111                                                  if (((word >> 29) & 0x1) == 0)
4112                                                    {
4113                                                      if (((word >> 30) & 0x1) == 0)
4114                                                        {
4115                                                          /* 33222222222211111111110000000000
4116                                                             10987654321098765432109876543210
4117                                                             xxxxxxxxxx000000xxxxx1xx0111000x
4118                                                             saddl.  */
4119                                                          return 38;
4120                                                        }
4121                                                      else
4122                                                        {
4123                                                          /* 33222222222211111111110000000000
4124                                                             10987654321098765432109876543210
4125                                                             xxxxxxxxxx000000xxxxx1xx0111001x
4126                                                             saddl2.  */
4127                                                          return 39;
4128                                                        }
4129                                                    }
4130                                                  else
4131                                                    {
4132                                                      if (((word >> 30) & 0x1) == 0)
4133                                                        {
4134                                                          /* 33222222222211111111110000000000
4135                                                             10987654321098765432109876543210
4136                                                             xxxxxxxxxx000000xxxxx1xx0111010x
4137                                                             uaddl.  */
4138                                                          return 70;
4139                                                        }
4140                                                      else
4141                                                        {
4142                                                          /* 33222222222211111111110000000000
4143                                                             10987654321098765432109876543210
4144                                                             xxxxxxxxxx000000xxxxx1xx0111011x
4145                                                             uaddl2.  */
4146                                                          return 71;
4147                                                        }
4148                                                    }
4149                                                }
4150                                              else
4151                                                {
4152                                                  if (((word >> 16) & 0x1) == 0)
4153                                                    {
4154                                                      if (((word >> 17) & 0x1) == 0)
4155                                                        {
4156                                                          if (((word >> 18) & 0x1) == 0)
4157                                                            {
4158                                                              if (((word >> 19) & 0x1) == 0)
4159                                                                {
4160                                                                  if (((word >> 20) & 0x1) == 0)
4161                                                                    {
4162                                                                      /* 33222222222211111111110000000000
4163                                                                         10987654321098765432109876543210
4164                                                                         xxxxxxxxxx000000000001xx01111xxx
4165                                                                         fcvtns.  */
4166                                                                      return 608;
4167                                                                    }
4168                                                                  else
4169                                                                    {
4170                                                                      /* 33222222222211111111110000000000
4171                                                                         10987654321098765432109876543210
4172                                                                         xxxxxxxxxx000000000011xx01111xxx
4173                                                                         fcvtms.  */
4174                                                                      return 618;
4175                                                                    }
4176                                                                }
4177                                                              else
4178                                                                {
4179                                                                  if (((word >> 20) & 0x1) == 0)
4180                                                                    {
4181                                                                      /* 33222222222211111111110000000000
4182                                                                         10987654321098765432109876543210
4183                                                                         xxxxxxxxxx000000000101xx01111xxx
4184                                                                         fcvtps.  */
4185                                                                      return 616;
4186                                                                    }
4187                                                                  else
4188                                                                    {
4189                                                                      /* 33222222222211111111110000000000
4190                                                                         10987654321098765432109876543210
4191                                                                         xxxxxxxxxx000000000111xx01111xxx
4192                                                                         fcvtzs.  */
4193                                                                      return 620;
4194                                                                    }
4195                                                                }
4196                                                            }
4197                                                          else
4198                                                            {
4199                                                              /* 33222222222211111111110000000000
4200                                                                 10987654321098765432109876543210
4201                                                                 xxxxxxxxxx000000001xx1xx01111xxx
4202                                                                 fcvtas.  */
4203                                                              return 612;
4204                                                            }
4205                                                        }
4206                                                      else
4207                                                        {
4208                                                          if (((word >> 18) & 0x1) == 0)
4209                                                            {
4210                                                              /* 33222222222211111111110000000000
4211                                                                 10987654321098765432109876543210
4212                                                                 xxxxxxxxxx000000010xx1xx01111xxx
4213                                                                 scvtf.  */
4214                                                              return 610;
4215                                                            }
4216                                                          else
4217                                                            {
4218                                                              if (((word >> 19) & 0x1) == 0)
4219                                                                {
4220                                                                  /* 33222222222211111111110000000000
4221                                                                     10987654321098765432109876543210
4222                                                                     xxxxxxxxxx0000000110x1xx01111xxx
4223                                                                     fmov.  */
4224                                                                  return 614;
4225                                                                }
4226                                                              else
4227                                                                {
4228                                                                  /* 33222222222211111111110000000000
4229                                                                     10987654321098765432109876543210
4230                                                                     xxxxxxxxxx0000000111x1xx01111xxx
4231                                                                     fmov.  */
4232                                                                  return 622;
4233                                                                }
4234                                                            }
4235                                                        }
4236                                                    }
4237                                                  else
4238                                                    {
4239                                                      if (((word >> 17) & 0x1) == 0)
4240                                                        {
4241                                                          if (((word >> 18) & 0x1) == 0)
4242                                                            {
4243                                                              if (((word >> 19) & 0x1) == 0)
4244                                                                {
4245                                                                  if (((word >> 20) & 0x1) == 0)
4246                                                                    {
4247                                                                      /* 33222222222211111111110000000000
4248                                                                         10987654321098765432109876543210
4249                                                                         xxxxxxxxxx000000100001xx01111xxx
4250                                                                         fcvtnu.  */
4251                                                                      return 609;
4252                                                                    }
4253                                                                  else
4254                                                                    {
4255                                                                      /* 33222222222211111111110000000000
4256                                                                         10987654321098765432109876543210
4257                                                                         xxxxxxxxxx000000100011xx01111xxx
4258                                                                         fcvtmu.  */
4259                                                                      return 619;
4260                                                                    }
4261                                                                }
4262                                                              else
4263                                                                {
4264                                                                  if (((word >> 20) & 0x1) == 0)
4265                                                                    {
4266                                                                      /* 33222222222211111111110000000000
4267                                                                         10987654321098765432109876543210
4268                                                                         xxxxxxxxxx000000100101xx01111xxx
4269                                                                         fcvtpu.  */
4270                                                                      return 617;
4271                                                                    }
4272                                                                  else
4273                                                                    {
4274                                                                      /* 33222222222211111111110000000000
4275                                                                         10987654321098765432109876543210
4276                                                                         xxxxxxxxxx000000100111xx01111xxx
4277                                                                         fcvtzu.  */
4278                                                                      return 621;
4279                                                                    }
4280                                                                }
4281                                                            }
4282                                                          else
4283                                                            {
4284                                                              /* 33222222222211111111110000000000
4285                                                                 10987654321098765432109876543210
4286                                                                 xxxxxxxxxx000000101xx1xx01111xxx
4287                                                                 fcvtau.  */
4288                                                              return 613;
4289                                                            }
4290                                                        }
4291                                                      else
4292                                                        {
4293                                                          if (((word >> 18) & 0x1) == 0)
4294                                                            {
4295                                                              /* 33222222222211111111110000000000
4296                                                                 10987654321098765432109876543210
4297                                                                 xxxxxxxxxx000000110xx1xx01111xxx
4298                                                                 ucvtf.  */
4299                                                              return 611;
4300                                                            }
4301                                                          else
4302                                                            {
4303                                                              if (((word >> 19) & 0x1) == 0)
4304                                                                {
4305                                                                  /* 33222222222211111111110000000000
4306                                                                     10987654321098765432109876543210
4307                                                                     xxxxxxxxxx0000001110x1xx01111xxx
4308                                                                     fmov.  */
4309                                                                  return 615;
4310                                                                }
4311                                                              else
4312                                                                {
4313                                                                  /* 33222222222211111111110000000000
4314                                                                     10987654321098765432109876543210
4315                                                                     xxxxxxxxxx0000001111x1xx01111xxx
4316                                                                     fmov.  */
4317                                                                  return 623;
4318                                                                }
4319                                                            }
4320                                                        }
4321                                                    }
4322                                                }
4323                                            }
4324                                          else
4325                                            {
4326                                              if (((word >> 29) & 0x1) == 0)
4327                                                {
4328                                                  if (((word >> 30) & 0x1) == 0)
4329                                                    {
4330                                                      /* 33222222222211111111110000000000
4331                                                         10987654321098765432109876543210
4332                                                         xxxxxxxxxx000001xxxxx1xx0111x00x
4333                                                         smlal.  */
4334                                                      return 54;
4335                                                    }
4336                                                  else
4337                                                    {
4338                                                      /* 33222222222211111111110000000000
4339                                                         10987654321098765432109876543210
4340                                                         xxxxxxxxxx000001xxxxx1xx0111x01x
4341                                                         smlal2.  */
4342                                                      return 55;
4343                                                    }
4344                                                }
4345                                              else
4346                                                {
4347                                                  if (((word >> 30) & 0x1) == 0)
4348                                                    {
4349                                                      /* 33222222222211111111110000000000
4350                                                         10987654321098765432109876543210
4351                                                         xxxxxxxxxx000001xxxxx1xx0111x10x
4352                                                         umlal.  */
4353                                                      return 86;
4354                                                    }
4355                                                  else
4356                                                    {
4357                                                      /* 33222222222211111111110000000000
4358                                                         10987654321098765432109876543210
4359                                                         xxxxxxxxxx000001xxxxx1xx0111x11x
4360                                                         umlal2.  */
4361                                                      return 87;
4362                                                    }
4363                                                }
4364                                            }
4365                                        }
4366                                      else
4367                                        {
4368                                          if (((word >> 28) & 0x1) == 0)
4369                                            {
4370                                              if (((word >> 15) & 0x1) == 0)
4371                                                {
4372                                                  if (((word >> 29) & 0x1) == 0)
4373                                                    {
4374                                                      if (((word >> 30) & 0x1) == 0)
4375                                                        {
4376                                                          /* 33222222222211111111110000000000
4377                                                             10987654321098765432109876543210
4378                                                             xxxxxxxxxx000010xxxxx1xx0111000x
4379                                                             addhn.  */
4380                                                          return 46;
4381                                                        }
4382                                                      else
4383                                                        {
4384                                                          /* 33222222222211111111110000000000
4385                                                             10987654321098765432109876543210
4386                                                             xxxxxxxxxx000010xxxxx1xx0111001x
4387                                                             addhn2.  */
4388                                                          return 47;
4389                                                        }
4390                                                    }
4391                                                  else
4392                                                    {
4393                                                      if (((word >> 30) & 0x1) == 0)
4394                                                        {
4395                                                          /* 33222222222211111111110000000000
4396                                                             10987654321098765432109876543210
4397                                                             xxxxxxxxxx000010xxxxx1xx0111010x
4398                                                             raddhn.  */
4399                                                          return 78;
4400                                                        }
4401                                                      else
4402                                                        {
4403                                                          /* 33222222222211111111110000000000
4404                                                             10987654321098765432109876543210
4405                                                             xxxxxxxxxx000010xxxxx1xx0111011x
4406                                                             raddhn2.  */
4407                                                          return 79;
4408                                                        }
4409                                                    }
4410                                                }
4411                                              else
4412                                                {
4413                                                  if (((word >> 29) & 0x1) == 0)
4414                                                    {
4415                                                      if (((word >> 30) & 0x1) == 0)
4416                                                        {
4417                                                          /* 33222222222211111111110000000000
4418                                                             10987654321098765432109876543210
4419                                                             xxxxxxxxxx000011xxxxx1xx0111000x
4420                                                             smull.  */
4421                                                          return 62;
4422                                                        }
4423                                                      else
4424                                                        {
4425                                                          /* 33222222222211111111110000000000
4426                                                             10987654321098765432109876543210
4427                                                             xxxxxxxxxx000011xxxxx1xx0111001x
4428                                                             smull2.  */
4429                                                          return 63;
4430                                                        }
4431                                                    }
4432                                                  else
4433                                                    {
4434                                                      if (((word >> 30) & 0x1) == 0)
4435                                                        {
4436                                                          /* 33222222222211111111110000000000
4437                                                             10987654321098765432109876543210
4438                                                             xxxxxxxxxx000011xxxxx1xx0111010x
4439                                                             umull.  */
4440                                                          return 90;
4441                                                        }
4442                                                      else
4443                                                        {
4444                                                          /* 33222222222211111111110000000000
4445                                                             10987654321098765432109876543210
4446                                                             xxxxxxxxxx000011xxxxx1xx0111011x
4447                                                             umull2.  */
4448                                                          return 91;
4449                                                        }
4450                                                    }
4451                                                }
4452                                            }
4453                                          else
4454                                            {
4455                                              if (((word >> 17) & 0x1) == 0)
4456                                                {
4457                                                  if (((word >> 15) & 0x1) == 0)
4458                                                    {
4459                                                      if (((word >> 16) & 0x1) == 0)
4460                                                        {
4461                                                          if (((word >> 18) & 0x1) == 0)
4462                                                            {
4463                                                              /* 33222222222211111111110000000000
4464                                                                 10987654321098765432109876543210
4465                                                                 xxxxxxxxxx000010000xx1xx01111xxx
4466                                                                 fmov.  */
4467                                                              return 630;
4468                                                            }
4469                                                          else
4470                                                            {
4471                                                              /* 33222222222211111111110000000000
4472                                                                 10987654321098765432109876543210
4473                                                                 xxxxxxxxxx000010001xx1xx01111xxx
4474                                                                 frintn.  */
4475                                                              return 635;
4476                                                            }
4477                                                        }
4478                                                      else
4479                                                        {
4480                                                          if (((word >> 18) & 0x1) == 0)
4481                                                            {
4482                                                              /* 33222222222211111111110000000000
4483                                                                 10987654321098765432109876543210
4484                                                                 xxxxxxxxxx000010100xx1xx01111xxx
4485                                                                 fneg.  */
4486                                                              return 632;
4487                                                            }
4488                                                          else
4489                                                            {
4490                                                              /* 33222222222211111111110000000000
4491                                                                 10987654321098765432109876543210
4492                                                                 xxxxxxxxxx000010101xx1xx01111xxx
4493                                                                 frintm.  */
4494                                                              return 637;
4495                                                            }
4496                                                        }
4497                                                    }
4498                                                  else
4499                                                    {
4500                                                      if (((word >> 16) & 0x1) == 0)
4501                                                        {
4502                                                          if (((word >> 18) & 0x1) == 0)
4503                                                            {
4504                                                              /* 33222222222211111111110000000000
4505                                                                 10987654321098765432109876543210
4506                                                                 xxxxxxxxxx000011000xx1xx01111xxx
4507                                                                 fabs.  */
4508                                                              return 631;
4509                                                            }
4510                                                          else
4511                                                            {
4512                                                              /* 33222222222211111111110000000000
4513                                                                 10987654321098765432109876543210
4514                                                                 xxxxxxxxxx000011001xx1xx01111xxx
4515                                                                 frintp.  */
4516                                                              return 636;
4517                                                            }
4518                                                        }
4519                                                      else
4520                                                        {
4521                                                          if (((word >> 18) & 0x1) == 0)
4522                                                            {
4523                                                              /* 33222222222211111111110000000000
4524                                                                 10987654321098765432109876543210
4525                                                                 xxxxxxxxxx000011100xx1xx01111xxx
4526                                                                 fsqrt.  */
4527                                                              return 633;
4528                                                            }
4529                                                          else
4530                                                            {
4531                                                              /* 33222222222211111111110000000000
4532                                                                 10987654321098765432109876543210
4533                                                                 xxxxxxxxxx000011101xx1xx01111xxx
4534                                                                 frintz.  */
4535                                                              return 638;
4536                                                            }
4537                                                        }
4538                                                    }
4539                                                }
4540                                              else
4541                                                {
4542                                                  if (((word >> 18) & 0x1) == 0)
4543                                                    {
4544                                                      /* 33222222222211111111110000000000
4545                                                         10987654321098765432109876543210
4546                                                         xxxxxxxxxx00001xx10xx1xx01111xxx
4547                                                         fcvt.  */
4548                                                      return 634;
4549                                                    }
4550                                                  else
4551                                                    {
4552                                                      if (((word >> 15) & 0x1) == 0)
4553                                                        {
4554                                                          if (((word >> 16) & 0x1) == 0)
4555                                                            {
4556                                                              /* 33222222222211111111110000000000
4557                                                                 10987654321098765432109876543210
4558                                                                 xxxxxxxxxx000010011xx1xx01111xxx
4559                                                                 frinta.  */
4560                                                              return 639;
4561                                                            }
4562                                                          else
4563                                                            {
4564                                                              /* 33222222222211111111110000000000
4565                                                                 10987654321098765432109876543210
4566                                                                 xxxxxxxxxx000010111xx1xx01111xxx
4567                                                                 frintx.  */
4568                                                              return 640;
4569                                                            }
4570                                                        }
4571                                                      else
4572                                                        {
4573                                                          /* 33222222222211111111110000000000
4574                                                             10987654321098765432109876543210
4575                                                             xxxxxxxxxx000011x11xx1xx01111xxx
4576                                                             frinti.  */
4577                                                          return 641;
4578                                                        }
4579                                                    }
4580                                                }
4581                                            }
4582                                        }
4583                                    }
4584                                  else
4585                                    {
4586                                      if (((word >> 14) & 0x1) == 0)
4587                                        {
4588                                          if (((word >> 15) & 0x1) == 0)
4589                                            {
4590                                              if (((word >> 28) & 0x1) == 0)
4591                                                {
4592                                                  if (((word >> 29) & 0x1) == 0)
4593                                                    {
4594                                                      if (((word >> 30) & 0x1) == 0)
4595                                                        {
4596                                                          /* 33222222222211111111110000000000
4597                                                             10987654321098765432109876543210
4598                                                             xxxxxxxxxx000100xxxxx1xx0111000x
4599                                                             ssubl.  */
4600                                                          return 42;
4601                                                        }
4602                                                      else
4603                                                        {
4604                                                          /* 33222222222211111111110000000000
4605                                                             10987654321098765432109876543210
4606                                                             xxxxxxxxxx000100xxxxx1xx0111001x
4607                                                             ssubl2.  */
4608                                                          return 43;
4609                                                        }
4610                                                    }
4611                                                  else
4612                                                    {
4613                                                      if (((word >> 30) & 0x1) == 0)
4614                                                        {
4615                                                          /* 33222222222211111111110000000000
4616                                                             10987654321098765432109876543210
4617                                                             xxxxxxxxxx000100xxxxx1xx0111010x
4618                                                             usubl.  */
4619                                                          return 74;
4620                                                        }
4621                                                      else
4622                                                        {
4623                                                          /* 33222222222211111111110000000000
4624                                                             10987654321098765432109876543210
4625                                                             xxxxxxxxxx000100xxxxx1xx0111011x
4626                                                             usubl2.  */
4627                                                          return 75;
4628                                                        }
4629                                                    }
4630                                                }
4631                                              else
4632                                                {
4633                                                  if (((word >> 3) & 0x1) == 0)
4634                                                    {
4635                                                      if (((word >> 4) & 0x1) == 0)
4636                                                        {
4637                                                          /* 33222222222211111111110000000000
4638                                                             10987654321098765432109876543210
4639                                                             xxx00xxxxx000100xxxxx1xx01111xxx
4640                                                             fcmp.  */
4641                                                          return 626;
4642                                                        }
4643                                                      else
4644                                                        {
4645                                                          /* 33222222222211111111110000000000
4646                                                             10987654321098765432109876543210
4647                                                             xxx01xxxxx000100xxxxx1xx01111xxx
4648                                                             fcmpe.  */
4649                                                          return 627;
4650                                                        }
4651                                                    }
4652                                                  else
4653                                                    {
4654                                                      if (((word >> 4) & 0x1) == 0)
4655                                                        {
4656                                                          /* 33222222222211111111110000000000
4657                                                             10987654321098765432109876543210
4658                                                             xxx10xxxxx000100xxxxx1xx01111xxx
4659                                                             fcmp.  */
4660                                                          return 628;
4661                                                        }
4662                                                      else
4663                                                        {
4664                                                          /* 33222222222211111111110000000000
4665                                                             10987654321098765432109876543210
4666                                                             xxx11xxxxx000100xxxxx1xx01111xxx
4667                                                             fcmpe.  */
4668                                                          return 629;
4669                                                        }
4670                                                    }
4671                                                }
4672                                            }
4673                                          else
4674                                            {
4675                                              if (((word >> 29) & 0x1) == 0)
4676                                                {
4677                                                  if (((word >> 30) & 0x1) == 0)
4678                                                    {
4679                                                      /* 33222222222211111111110000000000
4680                                                         10987654321098765432109876543210
4681                                                         xxxxxxxxxx000101xxxxx1xx0111x00x
4682                                                         smlsl.  */
4683                                                      return 58;
4684                                                    }
4685                                                  else
4686                                                    {
4687                                                      /* 33222222222211111111110000000000
4688                                                         10987654321098765432109876543210
4689                                                         xxxxxxxxxx000101xxxxx1xx0111x01x
4690                                                         smlsl2.  */
4691                                                      return 59;
4692                                                    }
4693                                                }
4694                                              else
4695                                                {
4696                                                  if (((word >> 30) & 0x1) == 0)
4697                                                    {
4698                                                      /* 33222222222211111111110000000000
4699                                                         10987654321098765432109876543210
4700                                                         xxxxxxxxxx000101xxxxx1xx0111x10x
4701                                                         umlsl.  */
4702                                                      return 88;
4703                                                    }
4704                                                  else
4705                                                    {
4706                                                      /* 33222222222211111111110000000000
4707                                                         10987654321098765432109876543210
4708                                                         xxxxxxxxxx000101xxxxx1xx0111x11x
4709                                                         umlsl2.  */
4710                                                      return 89;
4711                                                    }
4712                                                }
4713                                            }
4714                                        }
4715                                      else
4716                                        {
4717                                          if (((word >> 15) & 0x1) == 0)
4718                                            {
4719                                              if (((word >> 29) & 0x1) == 0)
4720                                                {
4721                                                  if (((word >> 30) & 0x1) == 0)
4722                                                    {
4723                                                      /* 33222222222211111111110000000000
4724                                                         10987654321098765432109876543210
4725                                                         xxxxxxxxxx000110xxxxx1xx0111x00x
4726                                                         subhn.  */
4727                                                      return 50;
4728                                                    }
4729                                                  else
4730                                                    {
4731                                                      /* 33222222222211111111110000000000
4732                                                         10987654321098765432109876543210
4733                                                         xxxxxxxxxx000110xxxxx1xx0111x01x
4734                                                         subhn2.  */
4735                                                      return 51;
4736                                                    }
4737                                                }
4738                                              else
4739                                                {
4740                                                  if (((word >> 30) & 0x1) == 0)
4741                                                    {
4742                                                      /* 33222222222211111111110000000000
4743                                                         10987654321098765432109876543210
4744                                                         xxxxxxxxxx000110xxxxx1xx0111x10x
4745                                                         rsubhn.  */
4746                                                      return 82;
4747                                                    }
4748                                                  else
4749                                                    {
4750                                                      /* 33222222222211111111110000000000
4751                                                         10987654321098765432109876543210
4752                                                         xxxxxxxxxx000110xxxxx1xx0111x11x
4753                                                         rsubhn2.  */
4754                                                      return 83;
4755                                                    }
4756                                                }
4757                                            }
4758                                          else
4759                                            {
4760                                              if (((word >> 22) & 0x1) == 0)
4761                                                {
4762                                                  if (((word >> 30) & 0x1) == 0)
4763                                                    {
4764                                                      /* 33222222222211111111110000000000
4765                                                         10987654321098765432109876543210
4766                                                         xxxxxxxxxx000111xxxxx10x0111xx0x
4767                                                         pmull.  */
4768                                                      return 66;
4769                                                    }
4770                                                  else
4771                                                    {
4772                                                      /* 33222222222211111111110000000000
4773                                                         10987654321098765432109876543210
4774                                                         xxxxxxxxxx000111xxxxx10x0111xx1x
4775                                                         pmull2.  */
4776                                                      return 68;
4777                                                    }
4778                                                }
4779                                              else
4780                                                {
4781                                                  if (((word >> 30) & 0x1) == 0)
4782                                                    {
4783                                                      /* 33222222222211111111110000000000
4784                                                         10987654321098765432109876543210
4785                                                         xxxxxxxxxx000111xxxxx11x0111xx0x
4786                                                         pmull.  */
4787                                                      return 67;
4788                                                    }
4789                                                  else
4790                                                    {
4791                                                      /* 33222222222211111111110000000000
4792                                                         10987654321098765432109876543210
4793                                                         xxxxxxxxxx000111xxxxx11x0111xx1x
4794                                                         pmull2.  */
4795                                                      return 69;
4796                                                    }
4797                                                }
4798                                            }
4799                                        }
4800                                    }
4801                                }
4802                              else
4803                                {
4804                                  if (((word >> 28) & 0x1) == 0)
4805                                    {
4806                                      if (((word >> 13) & 0x1) == 0)
4807                                        {
4808                                          if (((word >> 14) & 0x1) == 0)
4809                                            {
4810                                              if (((word >> 15) & 0x1) == 0)
4811                                                {
4812                                                  if (((word >> 29) & 0x1) == 0)
4813                                                    {
4814                                                      if (((word >> 30) & 0x1) == 0)
4815                                                        {
4816                                                          /* 33222222222211111111110000000000
4817                                                             10987654321098765432109876543210
4818                                                             xxxxxxxxxx001000xxxxx1xx0111000x
4819                                                             saddw.  */
4820                                                          return 40;
4821                                                        }
4822                                                      else
4823                                                        {
4824                                                          /* 33222222222211111111110000000000
4825                                                             10987654321098765432109876543210
4826                                                             xxxxxxxxxx001000xxxxx1xx0111001x
4827                                                             saddw2.  */
4828                                                          return 41;
4829                                                        }
4830                                                    }
4831                                                  else
4832                                                    {
4833                                                      if (((word >> 30) & 0x1) == 0)
4834                                                        {
4835                                                          /* 33222222222211111111110000000000
4836                                                             10987654321098765432109876543210
4837                                                             xxxxxxxxxx001000xxxxx1xx0111010x
4838                                                             uaddw.  */
4839                                                          return 72;
4840                                                        }
4841                                                      else
4842                                                        {
4843                                                          /* 33222222222211111111110000000000
4844                                                             10987654321098765432109876543210
4845                                                             xxxxxxxxxx001000xxxxx1xx0111011x
4846                                                             uaddw2.  */
4847                                                          return 73;
4848                                                        }
4849                                                    }
4850                                                }
4851                                              else
4852                                                {
4853                                                  if (((word >> 30) & 0x1) == 0)
4854                                                    {
4855                                                      /* 33222222222211111111110000000000
4856                                                         10987654321098765432109876543210
4857                                                         xxxxxxxxxx001001xxxxx1xx01110x0x
4858                                                         sqdmlal.  */
4859                                                      return 56;
4860                                                    }
4861                                                  else
4862                                                    {
4863                                                      /* 33222222222211111111110000000000
4864                                                         10987654321098765432109876543210
4865                                                         xxxxxxxxxx001001xxxxx1xx01110x1x
4866                                                         sqdmlal2.  */
4867                                                      return 57;
4868                                                    }
4869                                                }
4870                                            }
4871                                          else
4872                                            {
4873                                              if (((word >> 15) & 0x1) == 0)
4874                                                {
4875                                                  if (((word >> 29) & 0x1) == 0)
4876                                                    {
4877                                                      if (((word >> 30) & 0x1) == 0)
4878                                                        {
4879                                                          /* 33222222222211111111110000000000
4880                                                             10987654321098765432109876543210
4881                                                             xxxxxxxxxx001010xxxxx1xx0111000x
4882                                                             sabal.  */
4883                                                          return 48;
4884                                                        }
4885                                                      else
4886                                                        {
4887                                                          /* 33222222222211111111110000000000
4888                                                             10987654321098765432109876543210
4889                                                             xxxxxxxxxx001010xxxxx1xx0111001x
4890                                                             sabal2.  */
4891                                                          return 49;
4892                                                        }
4893                                                    }
4894                                                  else
4895                                                    {
4896                                                      if (((word >> 30) & 0x1) == 0)
4897                                                        {
4898                                                          /* 33222222222211111111110000000000
4899                                                             10987654321098765432109876543210
4900                                                             xxxxxxxxxx001010xxxxx1xx0111010x
4901                                                             uabal.  */
4902                                                          return 80;
4903                                                        }
4904                                                      else
4905                                                        {
4906                                                          /* 33222222222211111111110000000000
4907                                                             10987654321098765432109876543210
4908                                                             xxxxxxxxxx001010xxxxx1xx0111011x
4909                                                             uabal2.  */
4910                                                          return 81;
4911                                                        }
4912                                                    }
4913                                                }
4914                                              else
4915                                                {
4916                                                  if (((word >> 30) & 0x1) == 0)
4917                                                    {
4918                                                      /* 33222222222211111111110000000000
4919                                                         10987654321098765432109876543210
4920                                                         xxxxxxxxxx001011xxxxx1xx01110x0x
4921                                                         sqdmull.  */
4922                                                      return 64;
4923                                                    }
4924                                                  else
4925                                                    {
4926                                                      /* 33222222222211111111110000000000
4927                                                         10987654321098765432109876543210
4928                                                         xxxxxxxxxx001011xxxxx1xx01110x1x
4929                                                         sqdmull2.  */
4930                                                      return 65;
4931                                                    }
4932                                                }
4933                                            }
4934                                        }
4935                                      else
4936                                        {
4937                                          if (((word >> 14) & 0x1) == 0)
4938                                            {
4939                                              if (((word >> 15) & 0x1) == 0)
4940                                                {
4941                                                  if (((word >> 29) & 0x1) == 0)
4942                                                    {
4943                                                      if (((word >> 30) & 0x1) == 0)
4944                                                        {
4945                                                          /* 33222222222211111111110000000000
4946                                                             10987654321098765432109876543210
4947                                                             xxxxxxxxxx001100xxxxx1xx0111000x
4948                                                             ssubw.  */
4949                                                          return 44;
4950                                                        }
4951                                                      else
4952                                                        {
4953                                                          /* 33222222222211111111110000000000
4954                                                             10987654321098765432109876543210
4955                                                             xxxxxxxxxx001100xxxxx1xx0111001x
4956                                                             ssubw2.  */
4957                                                          return 45;
4958                                                        }
4959                                                    }
4960                                                  else
4961                                                    {
4962                                                      if (((word >> 30) & 0x1) == 0)
4963                                                        {
4964                                                          /* 33222222222211111111110000000000
4965                                                             10987654321098765432109876543210
4966                                                             xxxxxxxxxx001100xxxxx1xx0111010x
4967                                                             usubw.  */
4968                                                          return 76;
4969                                                        }
4970                                                      else
4971                                                        {
4972                                                          /* 33222222222211111111110000000000
4973                                                             10987654321098765432109876543210
4974                                                             xxxxxxxxxx001100xxxxx1xx0111011x
4975                                                             usubw2.  */
4976                                                          return 77;
4977                                                        }
4978                                                    }
4979                                                }
4980                                              else
4981                                                {
4982                                                  if (((word >> 30) & 0x1) == 0)
4983                                                    {
4984                                                      /* 33222222222211111111110000000000
4985                                                         10987654321098765432109876543210
4986                                                         xxxxxxxxxx001101xxxxx1xx01110x0x
4987                                                         sqdmlsl.  */
4988                                                      return 60;
4989                                                    }
4990                                                  else
4991                                                    {
4992                                                      /* 33222222222211111111110000000000
4993                                                         10987654321098765432109876543210
4994                                                         xxxxxxxxxx001101xxxxx1xx01110x1x
4995                                                         sqdmlsl2.  */
4996                                                      return 61;
4997                                                    }
4998                                                }
4999                                            }
5000                                          else
5001                                            {
5002                                              if (((word >> 29) & 0x1) == 0)
5003                                                {
5004                                                  if (((word >> 30) & 0x1) == 0)
5005                                                    {
5006                                                      /* 33222222222211111111110000000000
5007                                                         10987654321098765432109876543210
5008                                                         xxxxxxxxxx00111xxxxxx1xx0111000x
5009                                                         sabdl.  */
5010                                                      return 52;
5011                                                    }
5012                                                  else
5013                                                    {
5014                                                      /* 33222222222211111111110000000000
5015                                                         10987654321098765432109876543210
5016                                                         xxxxxxxxxx00111xxxxxx1xx0111001x
5017                                                         sabdl2.  */
5018                                                      return 53;
5019                                                    }
5020                                                }
5021                                              else
5022                                                {
5023                                                  if (((word >> 30) & 0x1) == 0)
5024                                                    {
5025                                                      /* 33222222222211111111110000000000
5026                                                         10987654321098765432109876543210
5027                                                         xxxxxxxxxx00111xxxxxx1xx0111010x
5028                                                         uabdl.  */
5029                                                      return 84;
5030                                                    }
5031                                                  else
5032                                                    {
5033                                                      /* 33222222222211111111110000000000
5034                                                         10987654321098765432109876543210
5035                                                         xxxxxxxxxx00111xxxxxx1xx0111011x
5036                                                         uabdl2.  */
5037                                                      return 85;
5038                                                    }
5039                                                }
5040                                            }
5041                                        }
5042                                    }
5043                                  else
5044                                    {
5045                                      if (((word >> 30) & 0x1) == 0)
5046                                        {
5047                                          /* 33222222222211111111110000000000
5048                                             10987654321098765432109876543210
5049                                             xxxxxxxxxx001xxxxxxxx1xx01111x0x
5050                                             fmov.  */
5051                                          return 655;
5052                                        }
5053                                      else
5054                                        {
5055                                          if (((word >> 13) & 0x1) == 0)
5056                                            {
5057                                              if (((word >> 14) & 0x1) == 0)
5058                                                {
5059                                                  /* 33222222222211111111110000000000
5060                                                     10987654321098765432109876543210
5061                                                     xxxxxxxxxx00100xxxxxx1xx01111x1x
5062                                                     sqdmlal.  */
5063                                                  return 347;
5064                                                }
5065                                              else
5066                                                {
5067                                                  /* 33222222222211111111110000000000
5068                                                     10987654321098765432109876543210
5069                                                     xxxxxxxxxx00101xxxxxx1xx01111x1x
5070                                                     sqdmull.  */
5071                                                  return 349;
5072                                                }
5073                                            }
5074                                          else
5075                                            {
5076                                              /* 33222222222211111111110000000000
5077                                                 10987654321098765432109876543210
5078                                                 xxxxxxxxxx0011xxxxxxx1xx01111x1x
5079                                                 sqdmlsl.  */
5080                                              return 348;
5081                                            }
5082                                        }
5083                                    }
5084                                }
5085                            }
5086                          else
5087                            {
5088                              if (((word >> 12) & 0x1) == 0)
5089                                {
5090                                  if (((word >> 13) & 0x1) == 0)
5091                                    {
5092                                      if (((word >> 14) & 0x1) == 0)
5093                                        {
5094                                          if (((word >> 15) & 0x1) == 0)
5095                                            {
5096                                              if (((word >> 28) & 0x1) == 0)
5097                                                {
5098                                                  if (((word >> 29) & 0x1) == 0)
5099                                                    {
5100                                                      /* 33222222222211111111110000000000
5101                                                         10987654321098765432109876543210
5102                                                         xxxxxxxxxx010000xxxxx1xx011100xx
5103                                                         rev64.  */
5104                                                      return 146;
5105                                                    }
5106                                                  else
5107                                                    {
5108                                                      /* 33222222222211111111110000000000
5109                                                         10987654321098765432109876543210
5110                                                         xxxxxxxxxx010000xxxxx1xx011101xx
5111                                                         rev32.  */
5112                                                      return 182;
5113                                                    }
5114                                                }
5115                                              else
5116                                                {
5117                                                  if (((word >> 30) & 0x1) == 0)
5118                                                    {
5119                                                      /* 33222222222211111111110000000000
5120                                                         10987654321098765432109876543210
5121                                                         xxxxxxxxxx010000xxxxx1xx01111x0x
5122                                                         fmul.  */
5123                                                      return 642;
5124                                                    }
5125                                                  else
5126                                                    {
5127                                                      /* 33222222222211111111110000000000
5128                                                         10987654321098765432109876543210
5129                                                         xxxxxxxxxx010000xxxxx1xx01111x1x
5130                                                         sha1h.  */
5131                                                      return 545;
5132                                                    }
5133                                                }
5134                                            }
5135                                          else
5136                                            {
5137                                              if (((word >> 28) & 0x1) == 0)
5138                                                {
5139                                                  if (((word >> 16) & 0x1) == 0)
5140                                                    {
5141                                                      if (((word >> 29) & 0x1) == 0)
5142                                                        {
5143                                                          /* 33222222222211111111110000000000
5144                                                             10987654321098765432109876543210
5145                                                             xxxxxxxxxx0100010xxxx1xx011100xx
5146                                                             cmgt.  */
5147                                                          return 154;
5148                                                        }
5149                                                      else
5150                                                        {
5151                                                          /* 33222222222211111111110000000000
5152                                                             10987654321098765432109876543210
5153                                                             xxxxxxxxxx0100010xxxx1xx011101xx
5154                                                             cmge.  */
5155                                                          return 188;
5156                                                        }
5157                                                    }
5158                                                  else
5159                                                    {
5160                                                      if (((word >> 23) & 0x1) == 0)
5161                                                        {
5162                                                          if (((word >> 29) & 0x1) == 0)
5163                                                            {
5164                                                              /* 33222222222211111111110000000000
5165                                                                 10987654321098765432109876543210
5166                                                                 xxxxxxxxxx0100011xxxx1x0011100xx
5167                                                                 frintn.  */
5168                                                              return 166;
5169                                                            }
5170                                                          else
5171                                                            {
5172                                                              /* 33222222222211111111110000000000
5173                                                                 10987654321098765432109876543210
5174                                                                 xxxxxxxxxx0100011xxxx1x0011101xx
5175                                                                 frinta.  */
5176                                                              return 199;
5177                                                            }
5178                                                        }
5179                                                      else
5180                                                        {
5181                                                          /* 33222222222211111111110000000000
5182                                                             10987654321098765432109876543210
5183                                                             xxxxxxxxxx0100011xxxx1x101110xxx
5184                                                             frintp.  */
5185                                                          return 176;
5186                                                        }
5187                                                    }
5188                                                }
5189                                              else
5190                                                {
5191                                                  if (((word >> 29) & 0x1) == 0)
5192                                                    {
5193                                                      if (((word >> 30) & 0x1) == 0)
5194                                                        {
5195                                                          /* 33222222222211111111110000000000
5196                                                             10987654321098765432109876543210
5197                                                             xxxxxxxxxx010001xxxxx1xx0111100x
5198                                                             fnmul.  */
5199                                                          return 650;
5200                                                        }
5201                                                      else
5202                                                        {
5203                                                          /* 33222222222211111111110000000000
5204                                                             10987654321098765432109876543210
5205                                                             xxxxxxxxxx010001xxxxx1xx0111101x
5206                                                             cmgt.  */
5207                                                          return 403;
5208                                                        }
5209                                                    }
5210                                                  else
5211                                                    {
5212                                                      /* 33222222222211111111110000000000
5213                                                         10987654321098765432109876543210
5214                                                         xxxxxxxxxx010001xxxxx1xx011111xx
5215                                                         cmge.  */
5216                                                      return 421;
5217                                                    }
5218                                                }
5219                                            }
5220                                        }
5221                                      else
5222                                        {
5223                                          if (((word >> 15) & 0x1) == 0)
5224                                            {
5225                                              if (((word >> 28) & 0x1) == 0)
5226                                                {
5227                                                  if (((word >> 16) & 0x1) == 0)
5228                                                    {
5229                                                      if (((word >> 19) & 0x1) == 0)
5230                                                        {
5231                                                          if (((word >> 29) & 0x1) == 0)
5232                                                            {
5233                                                              /* 33222222222211111111110000000000
5234                                                                 10987654321098765432109876543210
5235                                                                 xxxxxxxxxx0100100xx0x1xx011100xx
5236                                                                 cls.  */
5237                                                              return 150;
5238                                                            }
5239                                                          else
5240                                                            {
5241                                                              /* 33222222222211111111110000000000
5242                                                                 10987654321098765432109876543210
5243                                                                 xxxxxxxxxx0100100xx0x1xx011101xx
5244                                                                 clz.  */
5245                                                              return 185;
5246                                                            }
5247                                                        }
5248                                                      else
5249                                                        {
5250                                                          /* 33222222222211111111110000000000
5251                                                             10987654321098765432109876543210
5252                                                             xxxxxxxxxx0100100xx1x1xx01110xxx
5253                                                             aese.  */
5254                                                          return 541;
5255                                                        }
5256                                                    }
5257                                                  else
5258                                                    {
5259                                                      if (((word >> 29) & 0x1) == 0)
5260                                                        {
5261                                                          if (((word >> 30) & 0x1) == 0)
5262                                                            {
5263                                                              /* 33222222222211111111110000000000
5264                                                                 10987654321098765432109876543210
5265                                                                 xxxxxxxxxx0100101xxxx1xx0111000x
5266                                                                 sqxtn.  */
5267                                                              return 160;
5268                                                            }
5269                                                          else
5270                                                            {
5271                                                              /* 33222222222211111111110000000000
5272                                                                 10987654321098765432109876543210
5273                                                                 xxxxxxxxxx0100101xxxx1xx0111001x
5274                                                                 sqxtn2.  */
5275                                                              return 161;
5276                                                            }
5277                                                        }
5278                                                      else
5279                                                        {
5280                                                          if (((word >> 30) & 0x1) == 0)
5281                                                            {
5282                                                              /* 33222222222211111111110000000000
5283                                                                 10987654321098765432109876543210
5284                                                                 xxxxxxxxxx0100101xxxx1xx0111010x
5285                                                                 uqxtn.  */
5286                                                              return 195;
5287                                                            }
5288                                                          else
5289                                                            {
5290                                                              /* 33222222222211111111110000000000
5291                                                                 10987654321098765432109876543210
5292                                                                 xxxxxxxxxx0100101xxxx1xx0111011x
5293                                                                 uqxtn2.  */
5294                                                              return 196;
5295                                                            }
5296                                                        }
5297                                                    }
5298                                                }
5299                                              else
5300                                                {
5301                                                  if (((word >> 29) & 0x1) == 0)
5302                                                    {
5303                                                      if (((word >> 30) & 0x1) == 0)
5304                                                        {
5305                                                          /* 33222222222211111111110000000000
5306                                                             10987654321098765432109876543210
5307                                                             xxxxxxxxxx010010xxxxx1xx0111100x
5308                                                             fmax.  */
5309                                                          return 646;
5310                                                        }
5311                                                      else
5312                                                        {
5313                                                          /* 33222222222211111111110000000000
5314                                                             10987654321098765432109876543210
5315                                                             xxxxxxxxxx010010xxxxx1xx0111101x
5316                                                             sqxtn.  */
5317                                                          return 407;
5318                                                        }
5319                                                    }
5320                                                  else
5321                                                    {
5322                                                      /* 33222222222211111111110000000000
5323                                                         10987654321098765432109876543210
5324                                                         xxxxxxxxxx010010xxxxx1xx011111xx
5325                                                         uqxtn.  */
5326                                                      return 425;
5327                                                    }
5328                                                }
5329                                            }
5330                                          else
5331                                            {
5332                                              if (((word >> 16) & 0x1) == 0)
5333                                                {
5334                                                  if (((word >> 20) & 0x1) == 0)
5335                                                    {
5336                                                      if (((word >> 28) & 0x1) == 0)
5337                                                        {
5338                                                          if (((word >> 29) & 0x1) == 0)
5339                                                            {
5340                                                              /* 33222222222211111111110000000000
5341                                                                 10987654321098765432109876543210
5342                                                                 xxxxxxxxxx0100110xxx01xx011100xx
5343                                                                 fcmgt.  */
5344                                                              return 172;
5345                                                            }
5346                                                          else
5347                                                            {
5348                                                              /* 33222222222211111111110000000000
5349                                                                 10987654321098765432109876543210
5350                                                                 xxxxxxxxxx0100110xxx01xx011101xx
5351                                                                 fcmge.  */
5352                                                              return 208;
5353                                                            }
5354                                                        }
5355                                                      else
5356                                                        {
5357                                                          if (((word >> 29) & 0x1) == 0)
5358                                                            {
5359                                                              /* 33222222222211111111110000000000
5360                                                                 10987654321098765432109876543210
5361                                                                 xxxxxxxxxx0100110xxx01xx011110xx
5362                                                                 fcmgt.  */
5363                                                              return 412;
5364                                                            }
5365                                                          else
5366                                                            {
5367                                                              /* 33222222222211111111110000000000
5368                                                                 10987654321098765432109876543210
5369                                                                 xxxxxxxxxx0100110xxx01xx011111xx
5370                                                                 fcmge.  */
5371                                                              return 431;
5372                                                            }
5373                                                        }
5374                                                    }
5375                                                  else
5376                                                    {
5377                                                      if (((word >> 23) & 0x1) == 0)
5378                                                        {
5379                                                          if (((word >> 28) & 0x1) == 0)
5380                                                            {
5381                                                              /* 33222222222211111111110000000000
5382                                                                 10987654321098765432109876543210
5383                                                                 xxxxxxxxxx0100110xxx11x001110xxx
5384                                                                 fmaxnmv.  */
5385                                                              return 34;
5386                                                            }
5387                                                          else
5388                                                            {
5389                                                              /* 33222222222211111111110000000000
5390                                                                 10987654321098765432109876543210
5391                                                                 xxxxxxxxxx0100110xxx11x001111xxx
5392                                                                 fmaxnmp.  */
5393                                                              return 439;
5394                                                            }
5395                                                        }
5396                                                      else
5397                                                        {
5398                                                          if (((word >> 28) & 0x1) == 0)
5399                                                            {
5400                                                              /* 33222222222211111111110000000000
5401                                                                 10987654321098765432109876543210
5402                                                                 xxxxxxxxxx0100110xxx11x101110xxx
5403                                                                 fminnmv.  */
5404                                                              return 36;
5405                                                            }
5406                                                          else
5407                                                            {
5408                                                              /* 33222222222211111111110000000000
5409                                                                 10987654321098765432109876543210
5410                                                                 xxxxxxxxxx0100110xxx11x101111xxx
5411                                                                 fminnmp.  */
5412                                                              return 442;
5413                                                            }
5414                                                        }
5415                                                    }
5416                                                }
5417                                              else
5418                                                {
5419                                                  if (((word >> 23) & 0x1) == 0)
5420                                                    {
5421                                                      if (((word >> 28) & 0x1) == 0)
5422                                                        {
5423                                                          if (((word >> 29) & 0x1) == 0)
5424                                                            {
5425                                                              /* 33222222222211111111110000000000
5426                                                                 10987654321098765432109876543210
5427                                                                 xxxxxxxxxx0100111xxxx1x0011100xx
5428                                                                 fcvtas.  */
5429                                                              return 170;
5430                                                            }
5431                                                          else
5432                                                            {
5433                                                              /* 33222222222211111111110000000000
5434                                                                 10987654321098765432109876543210
5435                                                                 xxxxxxxxxx0100111xxxx1x0011101xx
5436                                                                 fcvtau.  */
5437                                                              return 203;
5438                                                            }
5439                                                        }
5440                                                      else
5441                                                        {
5442                                                          if (((word >> 29) & 0x1) == 0)
5443                                                            {
5444                                                              /* 33222222222211111111110000000000
5445                                                                 10987654321098765432109876543210
5446                                                                 xxxxxxxxxx0100111xxxx1x0011110xx
5447                                                                 fcvtas.  */
5448                                                              return 410;
5449                                                            }
5450                                                          else
5451                                                            {
5452                                                              /* 33222222222211111111110000000000
5453                                                                 10987654321098765432109876543210
5454                                                                 xxxxxxxxxx0100111xxxx1x0011111xx
5455                                                                 fcvtau.  */
5456                                                              return 429;
5457                                                            }
5458                                                        }
5459                                                    }
5460                                                  else
5461                                                    {
5462                                                      if (((word >> 29) & 0x1) == 0)
5463                                                        {
5464                                                          /* 33222222222211111111110000000000
5465                                                             10987654321098765432109876543210
5466                                                             xxxxxxxxxx0100111xxxx1x10111x0xx
5467                                                             urecpe.  */
5468                                                          return 180;
5469                                                        }
5470                                                      else
5471                                                        {
5472                                                          /* 33222222222211111111110000000000
5473                                                             10987654321098765432109876543210
5474                                                             xxxxxxxxxx0100111xxxx1x10111x1xx
5475                                                             ursqrte.  */
5476                                                          return 214;
5477                                                        }
5478                                                    }
5479                                                }
5480                                            }
5481                                        }
5482                                    }
5483                                  else
5484                                    {
5485                                      if (((word >> 14) & 0x1) == 0)
5486                                        {
5487                                          if (((word >> 15) & 0x1) == 0)
5488                                            {
5489                                              if (((word >> 28) & 0x1) == 0)
5490                                                {
5491                                                  if (((word >> 16) & 0x1) == 0)
5492                                                    {
5493                                                      if (((word >> 29) & 0x1) == 0)
5494                                                        {
5495                                                          /* 33222222222211111111110000000000
5496                                                             10987654321098765432109876543210
5497                                                             xxxxxxxxxx0101000xxxx1xx011100xx
5498                                                             saddlp.  */
5499                                                          return 148;
5500                                                        }
5501                                                      else
5502                                                        {
5503                                                          /* 33222222222211111111110000000000
5504                                                             10987654321098765432109876543210
5505                                                             xxxxxxxxxx0101000xxxx1xx011101xx
5506                                                             uaddlp.  */
5507                                                          return 183;
5508                                                        }
5509                                                    }
5510                                                  else
5511                                                    {
5512                                                      if (((word >> 29) & 0x1) == 0)
5513                                                        {
5514                                                          if (((word >> 30) & 0x1) == 0)
5515                                                            {
5516                                                              /* 33222222222211111111110000000000
5517                                                                 10987654321098765432109876543210
5518                                                                 xxxxxxxxxx0101001xxxx1xx0111000x
5519                                                                 xtn.  */
5520                                                              return 158;
5521                                                            }
5522                                                          else
5523                                                            {
5524                                                              /* 33222222222211111111110000000000
5525                                                                 10987654321098765432109876543210
5526                                                                 xxxxxxxxxx0101001xxxx1xx0111001x
5527                                                                 xtn2.  */
5528                                                              return 159;
5529                                                            }
5530                                                        }
5531                                                      else
5532                                                        {
5533                                                          if (((word >> 30) & 0x1) == 0)
5534                                                            {
5535                                                              /* 33222222222211111111110000000000
5536                                                                 10987654321098765432109876543210
5537                                                                 xxxxxxxxxx0101001xxxx1xx0111010x
5538                                                                 sqxtun.  */
5539                                                              return 191;
5540                                                            }
5541                                                          else
5542                                                            {
5543                                                              /* 33222222222211111111110000000000
5544                                                                 10987654321098765432109876543210
5545                                                                 xxxxxxxxxx0101001xxxx1xx0111011x
5546                                                                 sqxtun2.  */
5547                                                              return 192;
5548                                                            }
5549                                                        }
5550                                                    }
5551                                                }
5552                                              else
5553                                                {
5554                                                  if (((word >> 29) & 0x1) == 0)
5555                                                    {
5556                                                      if (((word >> 30) & 0x1) == 0)
5557                                                        {
5558                                                          /* 33222222222211111111110000000000
5559                                                             10987654321098765432109876543210
5560                                                             xxxxxxxxxx010100xxxxx1xx0111100x
5561                                                             fadd.  */
5562                                                          return 644;
5563                                                        }
5564                                                      else
5565                                                        {
5566                                                          /* 33222222222211111111110000000000
5567                                                             10987654321098765432109876543210
5568                                                             xxxxxxxxxx010100xxxxx1xx0111101x
5569                                                             sha256su0.  */
5570                                                          return 547;
5571                                                        }
5572                                                    }
5573                                                  else
5574                                                    {
5575                                                      /* 33222222222211111111110000000000
5576                                                         10987654321098765432109876543210
5577                                                         xxxxxxxxxx010100xxxxx1xx011111xx
5578                                                         sqxtun.  */
5579                                                      return 424;
5580                                                    }
5581                                                }
5582                                            }
5583                                          else
5584                                            {
5585                                              if (((word >> 16) & 0x1) == 0)
5586                                                {
5587                                                  if (((word >> 20) & 0x1) == 0)
5588                                                    {
5589                                                      if (((word >> 28) & 0x1) == 0)
5590                                                        {
5591                                                          /* 33222222222211111111110000000000
5592                                                             10987654321098765432109876543210
5593                                                             xxxxxxxxxx0101010xxx01xx01110xxx
5594                                                             cmlt.  */
5595                                                          return 156;
5596                                                        }
5597                                                      else
5598                                                        {
5599                                                          /* 33222222222211111111110000000000
5600                                                             10987654321098765432109876543210
5601                                                             xxxxxxxxxx0101010xxx01xx01111xxx
5602                                                             cmlt.  */
5603                                                          return 405;
5604                                                        }
5605                                                    }
5606                                                  else
5607                                                    {
5608                                                      if (((word >> 29) & 0x1) == 0)
5609                                                        {
5610                                                          /* 33222222222211111111110000000000
5611                                                             10987654321098765432109876543210
5612                                                             xxxxxxxxxx0101010xxx11xx0111x0xx
5613                                                             smaxv.  */
5614                                                          return 28;
5615                                                        }
5616                                                      else
5617                                                        {
5618                                                          /* 33222222222211111111110000000000
5619                                                             10987654321098765432109876543210
5620                                                             xxxxxxxxxx0101010xxx11xx0111x1xx
5621                                                             umaxv.  */
5622                                                          return 32;
5623                                                        }
5624                                                    }
5625                                                }
5626                                              else
5627                                                {
5628                                                  if (((word >> 20) & 0x1) == 0)
5629                                                    {
5630                                                      if (((word >> 23) & 0x1) == 0)
5631                                                        {
5632                                                          if (((word >> 28) & 0x1) == 0)
5633                                                            {
5634                                                              if (((word >> 29) & 0x1) == 0)
5635                                                                {
5636                                                                  /* 33222222222211111111110000000000
5637                                                                     10987654321098765432109876543210
5638                                                                     xxxxxxxxxx0101011xxx01x0011100xx
5639                                                                     fcvtns.  */
5640                                                                  return 168;
5641                                                                }
5642                                                              else
5643                                                                {
5644                                                                  /* 33222222222211111111110000000000
5645                                                                     10987654321098765432109876543210
5646                                                                     xxxxxxxxxx0101011xxx01x0011101xx
5647                                                                     fcvtnu.  */
5648                                                                  return 201;
5649                                                                }
5650                                                            }
5651                                                          else
5652                                                            {
5653                                                              if (((word >> 29) & 0x1) == 0)
5654                                                                {
5655                                                                  /* 33222222222211111111110000000000
5656                                                                     10987654321098765432109876543210
5657                                                                     xxxxxxxxxx0101011xxx01x0011110xx
5658                                                                     fcvtns.  */
5659                                                                  return 408;
5660                                                                }
5661                                                              else
5662                                                                {
5663                                                                  /* 33222222222211111111110000000000
5664                                                                     10987654321098765432109876543210
5665                                                                     xxxxxxxxxx0101011xxx01x0011111xx
5666                                                                     fcvtnu.  */
5667                                                                  return 427;
5668                                                                }
5669                                                            }
5670                                                        }
5671                                                      else
5672                                                        {
5673                                                          if (((word >> 28) & 0x1) == 0)
5674                                                            {
5675                                                              if (((word >> 29) & 0x1) == 0)
5676                                                                {
5677                                                                  /* 33222222222211111111110000000000
5678                                                                     10987654321098765432109876543210
5679                                                                     xxxxxxxxxx0101011xxx01x1011100xx
5680                                                                     fcvtps.  */
5681                                                                  return 178;
5682                                                                }
5683                                                              else
5684                                                                {
5685                                                                  /* 33222222222211111111110000000000
5686                                                                     10987654321098765432109876543210
5687                                                                     xxxxxxxxxx0101011xxx01x1011101xx
5688                                                                     fcvtpu.  */
5689                                                                  return 212;
5690                                                                }
5691                                                            }
5692                                                          else
5693                                                            {
5694                                                              if (((word >> 29) & 0x1) == 0)
5695                                                                {
5696                                                                  /* 33222222222211111111110000000000
5697                                                                     10987654321098765432109876543210
5698                                                                     xxxxxxxxxx0101011xxx01x1011110xx
5699                                                                     fcvtps.  */
5700                                                                  return 415;
5701                                                                }
5702                                                              else
5703                                                                {
5704                                                                  /* 33222222222211111111110000000000
5705                                                                     10987654321098765432109876543210
5706                                                                     xxxxxxxxxx0101011xxx01x1011111xx
5707                                                                     fcvtpu.  */
5708                                                                  return 433;
5709                                                                }
5710                                                            }
5711                                                        }
5712                                                    }
5713                                                  else
5714                                                    {
5715                                                      if (((word >> 29) & 0x1) == 0)
5716                                                        {
5717                                                          /* 33222222222211111111110000000000
5718                                                             10987654321098765432109876543210
5719                                                             xxxxxxxxxx0101011xxx11xx0111x0xx
5720                                                             sminv.  */
5721                                                          return 29;
5722                                                        }
5723                                                      else
5724                                                        {
5725                                                          /* 33222222222211111111110000000000
5726                                                             10987654321098765432109876543210
5727                                                             xxxxxxxxxx0101011xxx11xx0111x1xx
5728                                                             uminv.  */
5729                                                          return 33;
5730                                                        }
5731                                                    }
5732                                                }
5733                                            }
5734                                        }
5735                                      else
5736                                        {
5737                                          if (((word >> 15) & 0x1) == 0)
5738                                            {
5739                                              if (((word >> 28) & 0x1) == 0)
5740                                                {
5741                                                  if (((word >> 16) & 0x1) == 0)
5742                                                    {
5743                                                      if (((word >> 19) & 0x1) == 0)
5744                                                        {
5745                                                          if (((word >> 29) & 0x1) == 0)
5746                                                            {
5747                                                              /* 33222222222211111111110000000000
5748                                                                 10987654321098765432109876543210
5749                                                                 xxxxxxxxxx0101100xx0x1xx011100xx
5750                                                                 sadalp.  */
5751                                                              return 152;
5752                                                            }
5753                                                          else
5754                                                            {
5755                                                              /* 33222222222211111111110000000000
5756                                                                 10987654321098765432109876543210
5757                                                                 xxxxxxxxxx0101100xx0x1xx011101xx
5758                                                                 uadalp.  */
5759                                                              return 186;
5760                                                            }
5761                                                        }
5762                                                      else
5763                                                        {
5764                                                          /* 33222222222211111111110000000000
5765                                                             10987654321098765432109876543210
5766                                                             xxxxxxxxxx0101100xx1x1xx01110xxx
5767                                                             aesmc.  */
5768                                                          return 543;
5769                                                        }
5770                                                    }
5771                                                  else
5772                                                    {
5773                                                      if (((word >> 29) & 0x1) == 0)
5774                                                        {
5775                                                          if (((word >> 30) & 0x1) == 0)
5776                                                            {
5777                                                              /* 33222222222211111111110000000000
5778                                                                 10987654321098765432109876543210
5779                                                                 xxxxxxxxxx0101101xxxx1xx0111000x
5780                                                                 fcvtn.  */
5781                                                              return 162;
5782                                                            }
5783                                                          else
5784                                                            {
5785                                                              /* 33222222222211111111110000000000
5786                                                                 10987654321098765432109876543210
5787                                                                 xxxxxxxxxx0101101xxxx1xx0111001x
5788                                                                 fcvtn2.  */
5789                                                              return 163;
5790                                                            }
5791                                                        }
5792                                                      else
5793                                                        {
5794                                                          if (((word >> 30) & 0x1) == 0)
5795                                                            {
5796                                                              /* 33222222222211111111110000000000
5797                                                                 10987654321098765432109876543210
5798                                                                 xxxxxxxxxx0101101xxxx1xx0111010x
5799                                                                 fcvtxn.  */
5800                                                              return 197;
5801                                                            }
5802                                                          else
5803                                                            {
5804                                                              /* 33222222222211111111110000000000
5805                                                                 10987654321098765432109876543210
5806                                                                 xxxxxxxxxx0101101xxxx1xx0111011x
5807                                                                 fcvtxn2.  */
5808                                                              return 198;
5809                                                            }
5810                                                        }
5811                                                    }
5812                                                }
5813                                              else
5814                                                {
5815                                                  if (((word >> 29) & 0x1) == 0)
5816                                                    {
5817                                                      /* 33222222222211111111110000000000
5818                                                         10987654321098765432109876543210
5819                                                         xxxxxxxxxx010110xxxxx1xx011110xx
5820                                                         fmaxnm.  */
5821                                                      return 648;
5822                                                    }
5823                                                  else
5824                                                    {
5825                                                      /* 33222222222211111111110000000000
5826                                                         10987654321098765432109876543210
5827                                                         xxxxxxxxxx010110xxxxx1xx011111xx
5828                                                         fcvtxn.  */
5829                                                      return 426;
5830                                                    }
5831                                                }
5832                                            }
5833                                          else
5834                                            {
5835                                              if (((word >> 28) & 0x1) == 0)
5836                                                {
5837                                                  /* 33222222222211111111110000000000
5838                                                     10987654321098765432109876543210
5839                                                     xxxxxxxxxx010111xxxxx1xx01110xxx
5840                                                     fcmlt.  */
5841                                                  return 174;
5842                                                }
5843                                              else
5844                                                {
5845                                                  /* 33222222222211111111110000000000
5846                                                     10987654321098765432109876543210
5847                                                     xxxxxxxxxx010111xxxxx1xx01111xxx
5848                                                     fcmlt.  */
5849                                                  return 414;
5850                                                }
5851                                            }
5852                                        }
5853                                    }
5854                                }
5855                              else
5856                                {
5857                                  if (((word >> 13) & 0x1) == 0)
5858                                    {
5859                                      if (((word >> 14) & 0x1) == 0)
5860                                        {
5861                                          if (((word >> 15) & 0x1) == 0)
5862                                            {
5863                                              if (((word >> 28) & 0x1) == 0)
5864                                                {
5865                                                  /* 33222222222211111111110000000000
5866                                                     10987654321098765432109876543210
5867                                                     xxxxxxxxxx011000xxxxx1xx01110xxx
5868                                                     rev16.  */
5869                                                  return 147;
5870                                                }
5871                                              else
5872                                                {
5873                                                  if (((word >> 30) & 0x1) == 0)
5874                                                    {
5875                                                      /* 33222222222211111111110000000000
5876                                                         10987654321098765432109876543210
5877                                                         xxxxxxxxxx011000xxxxx1xx01111x0x
5878                                                         fdiv.  */
5879                                                      return 643;
5880                                                    }
5881                                                  else
5882                                                    {
5883                                                      /* 33222222222211111111110000000000
5884                                                         10987654321098765432109876543210
5885                                                         xxxxxxxxxx011000xxxxx1xx01111x1x
5886                                                         sha1su1.  */
5887                                                      return 546;
5888                                                    }
5889                                                }
5890                                            }
5891                                          else
5892                                            {
5893                                              if (((word >> 16) & 0x1) == 0)
5894                                                {
5895                                                  if (((word >> 28) & 0x1) == 0)
5896                                                    {
5897                                                      if (((word >> 29) & 0x1) == 0)
5898                                                        {
5899                                                          /* 33222222222211111111110000000000
5900                                                             10987654321098765432109876543210
5901                                                             xxxxxxxxxx0110010xxxx1xx011100xx
5902                                                             cmeq.  */
5903                                                          return 155;
5904                                                        }
5905                                                      else
5906                                                        {
5907                                                          /* 33222222222211111111110000000000
5908                                                             10987654321098765432109876543210
5909                                                             xxxxxxxxxx0110010xxxx1xx011101xx
5910                                                             cmle.  */
5911                                                          return 189;
5912                                                        }
5913                                                    }
5914                                                  else
5915                                                    {
5916                                                      if (((word >> 29) & 0x1) == 0)
5917                                                        {
5918                                                          /* 33222222222211111111110000000000
5919                                                             10987654321098765432109876543210
5920                                                             xxxxxxxxxx0110010xxxx1xx011110xx
5921                                                             cmeq.  */
5922                                                          return 404;
5923                                                        }
5924                                                      else
5925                                                        {
5926                                                          /* 33222222222211111111110000000000
5927                                                             10987654321098765432109876543210
5928                                                             xxxxxxxxxx0110010xxxx1xx011111xx
5929                                                             cmle.  */
5930                                                          return 422;
5931                                                        }
5932                                                    }
5933                                                }
5934                                              else
5935                                                {
5936                                                  if (((word >> 23) & 0x1) == 0)
5937                                                    {
5938                                                      if (((word >> 29) & 0x1) == 0)
5939                                                        {
5940                                                          /* 33222222222211111111110000000000
5941                                                             10987654321098765432109876543210
5942                                                             xxxxxxxxxx0110011xxxx1x00111x0xx
5943                                                             frintm.  */
5944                                                          return 167;
5945                                                        }
5946                                                      else
5947                                                        {
5948                                                          /* 33222222222211111111110000000000
5949                                                             10987654321098765432109876543210
5950                                                             xxxxxxxxxx0110011xxxx1x00111x1xx
5951                                                             frintx.  */
5952                                                          return 200;
5953                                                        }
5954                                                    }
5955                                                  else
5956                                                    {
5957                                                      if (((word >> 29) & 0x1) == 0)
5958                                                        {
5959                                                          /* 33222222222211111111110000000000
5960                                                             10987654321098765432109876543210
5961                                                             xxxxxxxxxx0110011xxxx1x10111x0xx
5962                                                             frintz.  */
5963                                                          return 177;
5964                                                        }
5965                                                      else
5966                                                        {
5967                                                          /* 33222222222211111111110000000000
5968                                                             10987654321098765432109876543210
5969                                                             xxxxxxxxxx0110011xxxx1x10111x1xx
5970                                                             frinti.  */
5971                                                          return 211;
5972                                                        }
5973                                                    }
5974                                                }
5975                                            }
5976                                        }
5977                                      else
5978                                        {
5979                                          if (((word >> 15) & 0x1) == 0)
5980                                            {
5981                                              if (((word >> 28) & 0x1) == 0)
5982                                                {
5983                                                  if (((word >> 19) & 0x1) == 0)
5984                                                    {
5985                                                      if (((word >> 29) & 0x1) == 0)
5986                                                        {
5987                                                          /* 33222222222211111111110000000000
5988                                                             10987654321098765432109876543210
5989                                                             xxxxxxxxxx011010xxx0x1xx011100xx
5990                                                             cnt.  */
5991                                                          return 151;
5992                                                        }
5993                                                      else
5994                                                        {
5995                                                          if (((word >> 22) & 0x1) == 0)
5996                                                            {
5997                                                              /* 33222222222211111111110000000000
5998                                                                 10987654321098765432109876543210
5999                                                                 xxxxxxxxxx011010xxx0x10x011101xx
6000                                                                 not.  */
6001                                                              return 205;
6002                                                            }
6003                                                          else
6004                                                            {
6005                                                              /* 33222222222211111111110000000000
6006                                                                 10987654321098765432109876543210
6007                                                                 xxxxxxxxxx011010xxx0x11x011101xx
6008                                                                 rbit.  */
6009                                                              return 207;
6010                                                            }
6011                                                        }
6012                                                    }
6013                                                  else
6014                                                    {
6015                                                      /* 33222222222211111111110000000000
6016                                                         10987654321098765432109876543210
6017                                                         xxxxxxxxxx011010xxx1x1xx01110xxx
6018                                                         aesd.  */
6019                                                      return 542;
6020                                                    }
6021                                                }
6022                                              else
6023                                                {
6024                                                  /* 33222222222211111111110000000000
6025                                                     10987654321098765432109876543210
6026                                                     xxxxxxxxxx011010xxxxx1xx01111xxx
6027                                                     fmin.  */
6028                                                  return 647;
6029                                                }
6030                                            }
6031                                          else
6032                                            {
6033                                              if (((word >> 16) & 0x1) == 0)
6034                                                {
6035                                                  if (((word >> 20) & 0x1) == 0)
6036                                                    {
6037                                                      if (((word >> 28) & 0x1) == 0)
6038                                                        {
6039                                                          if (((word >> 29) & 0x1) == 0)
6040                                                            {
6041                                                              /* 33222222222211111111110000000000
6042                                                                 10987654321098765432109876543210
6043                                                                 xxxxxxxxxx0110110xxx01xx011100xx
6044                                                                 fcmeq.  */
6045                                                              return 173;
6046                                                            }
6047                                                          else
6048                                                            {
6049                                                              /* 33222222222211111111110000000000
6050                                                                 10987654321098765432109876543210
6051                                                                 xxxxxxxxxx0110110xxx01xx011101xx
6052                                                                 fcmle.  */
6053                                                              return 209;
6054                                                            }
6055                                                        }
6056                                                      else
6057                                                        {
6058                                                          if (((word >> 29) & 0x1) == 0)
6059                                                            {
6060                                                              /* 33222222222211111111110000000000
6061                                                                 10987654321098765432109876543210
6062                                                                 xxxxxxxxxx0110110xxx01xx011110xx
6063                                                                 fcmeq.  */
6064                                                              return 413;
6065                                                            }
6066                                                          else
6067                                                            {
6068                                                              /* 33222222222211111111110000000000
6069                                                                 10987654321098765432109876543210
6070                                                                 xxxxxxxxxx0110110xxx01xx011111xx
6071                                                                 fcmle.  */
6072                                                              return 432;
6073                                                            }
6074                                                        }
6075                                                    }
6076                                                  else
6077                                                    {
6078                                                      /* 33222222222211111111110000000000
6079                                                         10987654321098765432109876543210
6080                                                         xxxxxxxxxx0110110xxx11xx0111xxxx
6081                                                         faddp.  */
6082                                                      return 440;
6083                                                    }
6084                                                }
6085                                              else
6086                                                {
6087                                                  if (((word >> 23) & 0x1) == 0)
6088                                                    {
6089                                                      if (((word >> 28) & 0x1) == 0)
6090                                                        {
6091                                                          if (((word >> 29) & 0x1) == 0)
6092                                                            {
6093                                                              /* 33222222222211111111110000000000
6094                                                                 10987654321098765432109876543210
6095                                                                 xxxxxxxxxx0110111xxxx1x0011100xx
6096                                                                 scvtf.  */
6097                                                              return 171;
6098                                                            }
6099                                                          else
6100                                                            {
6101                                                              /* 33222222222211111111110000000000
6102                                                                 10987654321098765432109876543210
6103                                                                 xxxxxxxxxx0110111xxxx1x0011101xx
6104                                                                 ucvtf.  */
6105                                                              return 204;
6106                                                            }
6107                                                        }
6108                                                      else
6109                                                        {
6110                                                          if (((word >> 29) & 0x1) == 0)
6111                                                            {
6112                                                              /* 33222222222211111111110000000000
6113                                                                 10987654321098765432109876543210
6114                                                                 xxxxxxxxxx0110111xxxx1x0011110xx
6115                                                                 scvtf.  */
6116                                                              return 411;
6117                                                            }
6118                                                          else
6119                                                            {
6120                                                              /* 33222222222211111111110000000000
6121                                                                 10987654321098765432109876543210
6122                                                                 xxxxxxxxxx0110111xxxx1x0011111xx
6123                                                                 ucvtf.  */
6124                                                              return 430;
6125                                                            }
6126                                                        }
6127                                                    }
6128                                                  else
6129                                                    {
6130                                                      if (((word >> 28) & 0x1) == 0)
6131                                                        {
6132                                                          if (((word >> 29) & 0x1) == 0)
6133                                                            {
6134                                                              /* 33222222222211111111110000000000
6135                                                                 10987654321098765432109876543210
6136                                                                 xxxxxxxxxx0110111xxxx1x1011100xx
6137                                                                 frecpe.  */
6138                                                              return 181;
6139                                                            }
6140                                                          else
6141                                                            {
6142                                                              /* 33222222222211111111110000000000
6143                                                                 10987654321098765432109876543210
6144                                                                 xxxxxxxxxx0110111xxxx1x1011101xx
6145                                                                 frsqrte.  */
6146                                                              return 215;
6147                                                            }
6148                                                        }
6149                                                      else
6150                                                        {
6151                                                          if (((word >> 29) & 0x1) == 0)
6152                                                            {
6153                                                              /* 33222222222211111111110000000000
6154                                                                 10987654321098765432109876543210
6155                                                                 xxxxxxxxxx0110111xxxx1x1011110xx
6156                                                                 frecpe.  */
6157                                                              return 417;
6158                                                            }
6159                                                          else
6160                                                            {
6161                                                              /* 33222222222211111111110000000000
6162                                                                 10987654321098765432109876543210
6163                                                                 xxxxxxxxxx0110111xxxx1x1011111xx
6164                                                                 frsqrte.  */
6165                                                              return 435;
6166                                                            }
6167                                                        }
6168                                                    }
6169                                                }
6170                                            }
6171                                        }
6172                                    }
6173                                  else
6174                                    {
6175                                      if (((word >> 14) & 0x1) == 0)
6176                                        {
6177                                          if (((word >> 15) & 0x1) == 0)
6178                                            {
6179                                              if (((word >> 28) & 0x1) == 0)
6180                                                {
6181                                                  if (((word >> 16) & 0x1) == 0)
6182                                                    {
6183                                                      if (((word >> 20) & 0x1) == 0)
6184                                                        {
6185                                                          if (((word >> 29) & 0x1) == 0)
6186                                                            {
6187                                                              /* 33222222222211111111110000000000
6188                                                                 10987654321098765432109876543210
6189                                                                 xxxxxxxxxx0111000xxx01xx011100xx
6190                                                                 suqadd.  */
6191                                                              return 149;
6192                                                            }
6193                                                          else
6194                                                            {
6195                                                              /* 33222222222211111111110000000000
6196                                                                 10987654321098765432109876543210
6197                                                                 xxxxxxxxxx0111000xxx01xx011101xx
6198                                                                 usqadd.  */
6199                                                              return 184;
6200                                                            }
6201                                                        }
6202                                                      else
6203                                                        {
6204                                                          if (((word >> 29) & 0x1) == 0)
6205                                                            {
6206                                                              /* 33222222222211111111110000000000
6207                                                                 10987654321098765432109876543210
6208                                                                 xxxxxxxxxx0111000xxx11xx011100xx
6209                                                                 saddlv.  */
6210                                                              return 27;
6211                                                            }
6212                                                          else
6213                                                            {
6214                                                              /* 33222222222211111111110000000000
6215                                                                 10987654321098765432109876543210
6216                                                                 xxxxxxxxxx0111000xxx11xx011101xx
6217                                                                 uaddlv.  */
6218                                                              return 31;
6219                                                            }
6220                                                        }
6221                                                    }
6222                                                  else
6223                                                    {
6224                                                      if (((word >> 30) & 0x1) == 0)
6225                                                        {
6226                                                          /* 33222222222211111111110000000000
6227                                                             10987654321098765432109876543210
6228                                                             xxxxxxxxxx0111001xxxx1xx01110x0x
6229                                                             shll.  */
6230                                                          return 193;
6231                                                        }
6232                                                      else
6233                                                        {
6234                                                          /* 33222222222211111111110000000000
6235                                                             10987654321098765432109876543210
6236                                                             xxxxxxxxxx0111001xxxx1xx01110x1x
6237                                                             shll2.  */
6238                                                          return 194;
6239                                                        }
6240                                                    }
6241                                                }
6242                                              else
6243                                                {
6244                                                  if (((word >> 29) & 0x1) == 0)
6245                                                    {
6246                                                      if (((word >> 30) & 0x1) == 0)
6247                                                        {
6248                                                          /* 33222222222211111111110000000000
6249                                                             10987654321098765432109876543210
6250                                                             xxxxxxxxxx011100xxxxx1xx0111100x
6251                                                             fsub.  */
6252                                                          return 645;
6253                                                        }
6254                                                      else
6255                                                        {
6256                                                          /* 33222222222211111111110000000000
6257                                                             10987654321098765432109876543210
6258                                                             xxxxxxxxxx011100xxxxx1xx0111101x
6259                                                             suqadd.  */
6260                                                          return 401;
6261                                                        }
6262                                                    }
6263                                                  else
6264                                                    {
6265                                                      /* 33222222222211111111110000000000
6266                                                         10987654321098765432109876543210
6267                                                         xxxxxxxxxx011100xxxxx1xx011111xx
6268                                                         usqadd.  */
6269                                                      return 419;
6270                                                    }
6271                                                }
6272                                            }
6273                                          else
6274                                            {
6275                                              if (((word >> 16) & 0x1) == 0)
6276                                                {
6277                                                  if (((word >> 28) & 0x1) == 0)
6278                                                    {
6279                                                      if (((word >> 29) & 0x1) == 0)
6280                                                        {
6281                                                          /* 33222222222211111111110000000000
6282                                                             10987654321098765432109876543210
6283                                                             xxxxxxxxxx0111010xxxx1xx011100xx
6284                                                             abs.  */
6285                                                          return 157;
6286                                                        }
6287                                                      else
6288                                                        {
6289                                                          /* 33222222222211111111110000000000
6290                                                             10987654321098765432109876543210
6291                                                             xxxxxxxxxx0111010xxxx1xx011101xx
6292                                                             neg.  */
6293                                                          return 190;
6294                                                        }
6295                                                    }
6296                                                  else
6297                                                    {
6298                                                      if (((word >> 29) & 0x1) == 0)
6299                                                        {
6300                                                          /* 33222222222211111111110000000000
6301                                                             10987654321098765432109876543210
6302                                                             xxxxxxxxxx0111010xxxx1xx011110xx
6303                                                             abs.  */
6304                                                          return 406;
6305                                                        }
6306                                                      else
6307                                                        {
6308                                                          /* 33222222222211111111110000000000
6309                                                             10987654321098765432109876543210
6310                                                             xxxxxxxxxx0111010xxxx1xx011111xx
6311                                                             neg.  */
6312                                                          return 423;
6313                                                        }
6314                                                    }
6315                                                }
6316                                              else
6317                                                {
6318                                                  if (((word >> 20) & 0x1) == 0)
6319                                                    {
6320                                                      if (((word >> 23) & 0x1) == 0)
6321                                                        {
6322                                                          if (((word >> 28) & 0x1) == 0)
6323                                                            {
6324                                                              if (((word >> 29) & 0x1) == 0)
6325                                                                {
6326                                                                  /* 33222222222211111111110000000000
6327                                                                     10987654321098765432109876543210
6328                                                                     xxxxxxxxxx0111011xxx01x0011100xx
6329                                                                     fcvtms.  */
6330                                                                  return 169;
6331                                                                }
6332                                                              else
6333                                                                {
6334                                                                  /* 33222222222211111111110000000000
6335                                                                     10987654321098765432109876543210
6336                                                                     xxxxxxxxxx0111011xxx01x0011101xx
6337                                                                     fcvtmu.  */
6338                                                                  return 202;
6339                                                                }
6340                                                            }
6341                                                          else
6342                                                            {
6343                                                              if (((word >> 29) & 0x1) == 0)
6344                                                                {
6345                                                                  /* 33222222222211111111110000000000
6346                                                                     10987654321098765432109876543210
6347                                                                     xxxxxxxxxx0111011xxx01x0011110xx
6348                                                                     fcvtms.  */
6349                                                                  return 409;
6350                                                                }
6351                                                              else
6352                                                                {
6353                                                                  /* 33222222222211111111110000000000
6354                                                                     10987654321098765432109876543210
6355                                                                     xxxxxxxxxx0111011xxx01x0011111xx
6356                                                                     fcvtmu.  */
6357                                                                  return 428;
6358                                                                }
6359                                                            }
6360                                                        }
6361                                                      else
6362                                                        {
6363                                                          if (((word >> 28) & 0x1) == 0)
6364                                                            {
6365                                                              if (((word >> 29) & 0x1) == 0)
6366                                                                {
6367                                                                  /* 33222222222211111111110000000000
6368                                                                     10987654321098765432109876543210
6369                                                                     xxxxxxxxxx0111011xxx01x1011100xx
6370                                                                     fcvtzs.  */
6371                                                                  return 179;
6372                                                                }
6373                                                              else
6374                                                                {
6375                                                                  /* 33222222222211111111110000000000
6376                                                                     10987654321098765432109876543210
6377                                                                     xxxxxxxxxx0111011xxx01x1011101xx
6378                                                                     fcvtzu.  */
6379                                                                  return 213;
6380                                                                }
6381                                                            }
6382                                                          else
6383                                                            {
6384                                                              if (((word >> 29) & 0x1) == 0)
6385                                                                {
6386                                                                  /* 33222222222211111111110000000000
6387                                                                     10987654321098765432109876543210
6388                                                                     xxxxxxxxxx0111011xxx01x1011110xx
6389                                                                     fcvtzs.  */
6390                                                                  return 416;
6391                                                                }
6392                                                              else
6393                                                                {
6394                                                                  /* 33222222222211111111110000000000
6395                                                                     10987654321098765432109876543210
6396                                                                     xxxxxxxxxx0111011xxx01x1011111xx
6397                                                                     fcvtzu.  */
6398                                                                  return 434;
6399                                                                }
6400                                                            }
6401                                                        }
6402                                                    }
6403                                                  else
6404                                                    {
6405                                                      if (((word >> 28) & 0x1) == 0)
6406                                                        {
6407                                                          /* 33222222222211111111110000000000
6408                                                             10987654321098765432109876543210
6409                                                             xxxxxxxxxx0111011xxx11xx01110xxx
6410                                                             addv.  */
6411                                                          return 30;
6412                                                        }
6413                                                      else
6414                                                        {
6415                                                          /* 33222222222211111111110000000000
6416                                                             10987654321098765432109876543210
6417                                                             xxxxxxxxxx0111011xxx11xx01111xxx
6418                                                             addp.  */
6419                                                          return 438;
6420                                                        }
6421                                                    }
6422                                                }
6423                                            }
6424                                        }
6425                                      else
6426                                        {
6427                                          if (((word >> 15) & 0x1) == 0)
6428                                            {
6429                                              if (((word >> 28) & 0x1) == 0)
6430                                                {
6431                                                  if (((word >> 16) & 0x1) == 0)
6432                                                    {
6433                                                      if (((word >> 19) & 0x1) == 0)
6434                                                        {
6435                                                          if (((word >> 29) & 0x1) == 0)
6436                                                            {
6437                                                              /* 33222222222211111111110000000000
6438                                                                 10987654321098765432109876543210
6439                                                                 xxxxxxxxxx0111100xx0x1xx011100xx
6440                                                                 sqabs.  */
6441                                                              return 153;
6442                                                            }
6443                                                          else
6444                                                            {
6445                                                              /* 33222222222211111111110000000000
6446                                                                 10987654321098765432109876543210
6447                                                                 xxxxxxxxxx0111100xx0x1xx011101xx
6448                                                                 sqneg.  */
6449                                                              return 187;
6450                                                            }
6451                                                        }
6452                                                      else
6453                                                        {
6454                                                          /* 33222222222211111111110000000000
6455                                                             10987654321098765432109876543210
6456                                                             xxxxxxxxxx0111100xx1x1xx01110xxx
6457                                                             aesimc.  */
6458                                                          return 544;
6459                                                        }
6460                                                    }
6461                                                  else
6462                                                    {
6463                                                      if (((word >> 30) & 0x1) == 0)
6464                                                        {
6465                                                          /* 33222222222211111111110000000000
6466                                                             10987654321098765432109876543210
6467                                                             xxxxxxxxxx0111101xxxx1xx01110x0x
6468                                                             fcvtl.  */
6469                                                          return 164;
6470                                                        }
6471                                                      else
6472                                                        {
6473                                                          /* 33222222222211111111110000000000
6474                                                             10987654321098765432109876543210
6475                                                             xxxxxxxxxx0111101xxxx1xx01110x1x
6476                                                             fcvtl2.  */
6477                                                          return 165;
6478                                                        }
6479                                                    }
6480                                                }
6481                                              else
6482                                                {
6483                                                  if (((word >> 29) & 0x1) == 0)
6484                                                    {
6485                                                      if (((word >> 30) & 0x1) == 0)
6486                                                        {
6487                                                          /* 33222222222211111111110000000000
6488                                                             10987654321098765432109876543210
6489                                                             xxxxxxxxxx011110xxxxx1xx0111100x
6490                                                             fminnm.  */
6491                                                          return 649;
6492                                                        }
6493                                                      else
6494                                                        {
6495                                                          /* 33222222222211111111110000000000
6496                                                             10987654321098765432109876543210
6497                                                             xxxxxxxxxx011110xxxxx1xx0111101x
6498                                                             sqabs.  */
6499                                                          return 402;
6500                                                        }
6501                                                    }
6502                                                  else
6503                                                    {
6504                                                      /* 33222222222211111111110000000000
6505                                                         10987654321098765432109876543210
6506                                                         xxxxxxxxxx011110xxxxx1xx011111xx
6507                                                         sqneg.  */
6508                                                      return 420;
6509                                                    }
6510                                                }
6511                                            }
6512                                          else
6513                                            {
6514                                              if (((word >> 16) & 0x1) == 0)
6515                                                {
6516                                                  if (((word >> 20) & 0x1) == 0)
6517                                                    {
6518                                                      if (((word >> 29) & 0x1) == 0)
6519                                                        {
6520                                                          /* 33222222222211111111110000000000
6521                                                             10987654321098765432109876543210
6522                                                             xxxxxxxxxx0111110xxx01xx0111x0xx
6523                                                             fabs.  */
6524                                                          return 175;
6525                                                        }
6526                                                      else
6527                                                        {
6528                                                          /* 33222222222211111111110000000000
6529                                                             10987654321098765432109876543210
6530                                                             xxxxxxxxxx0111110xxx01xx0111x1xx
6531                                                             fneg.  */
6532                                                          return 210;
6533                                                        }
6534                                                    }
6535                                                  else
6536                                                    {
6537                                                      if (((word >> 23) & 0x1) == 0)
6538                                                        {
6539                                                          if (((word >> 28) & 0x1) == 0)
6540                                                            {
6541                                                              /* 33222222222211111111110000000000
6542                                                                 10987654321098765432109876543210
6543                                                                 xxxxxxxxxx0111110xxx11x001110xxx
6544                                                                 fmaxv.  */
6545                                                              return 35;
6546                                                            }
6547                                                          else
6548                                                            {
6549                                                              /* 33222222222211111111110000000000
6550                                                                 10987654321098765432109876543210
6551                                                                 xxxxxxxxxx0111110xxx11x001111xxx
6552                                                                 fmaxp.  */
6553                                                              return 441;
6554                                                            }
6555                                                        }
6556                                                      else
6557                                                        {
6558                                                          if (((word >> 28) & 0x1) == 0)
6559                                                            {
6560                                                              /* 33222222222211111111110000000000
6561                                                                 10987654321098765432109876543210
6562                                                                 xxxxxxxxxx0111110xxx11x101110xxx
6563                                                                 fminv.  */
6564                                                              return 37;
6565                                                            }
6566                                                          else
6567                                                            {
6568                                                              /* 33222222222211111111110000000000
6569                                                                 10987654321098765432109876543210
6570                                                                 xxxxxxxxxx0111110xxx11x101111xxx
6571                                                                 fminp.  */
6572                                                              return 443;
6573                                                            }
6574                                                        }
6575                                                    }
6576                                                }
6577                                              else
6578                                                {
6579                                                  if (((word >> 28) & 0x1) == 0)
6580                                                    {
6581                                                      /* 33222222222211111111110000000000
6582                                                         10987654321098765432109876543210
6583                                                         xxxxxxxxxx0111111xxxx1xx01110xxx
6584                                                         fsqrt.  */
6585                                                      return 216;
6586                                                    }
6587                                                  else
6588                                                    {
6589                                                      /* 33222222222211111111110000000000
6590                                                         10987654321098765432109876543210
6591                                                         xxxxxxxxxx0111111xxxx1xx01111xxx
6592                                                         frecpx.  */
6593                                                      return 418;
6594                                                    }
6595                                                }
6596                                            }
6597                                        }
6598                                    }
6599                                }
6600                            }
6601                        }
6602                      else
6603                        {
6604                          if (((word >> 11) & 0x1) == 0)
6605                            {
6606                              if (((word >> 28) & 0x1) == 0)
6607                                {
6608                                  if (((word >> 12) & 0x1) == 0)
6609                                    {
6610                                      if (((word >> 13) & 0x1) == 0)
6611                                        {
6612                                          if (((word >> 14) & 0x1) == 0)
6613                                            {
6614                                              if (((word >> 15) & 0x1) == 0)
6615                                                {
6616                                                  if (((word >> 29) & 0x1) == 0)
6617                                                    {
6618                                                      /* 33222222222211111111110000000000
6619                                                         10987654321098765432109876543210
6620                                                         xxxxxxxxxx100000xxxxx1xx011100xx
6621                                                         shadd.  */
6622                                                      return 223;
6623                                                    }
6624                                                  else
6625                                                    {
6626                                                      /* 33222222222211111111110000000000
6627                                                         10987654321098765432109876543210
6628                                                         xxxxxxxxxx100000xxxxx1xx011101xx
6629                                                         uhadd.  */
6630                                                      return 263;
6631                                                    }
6632                                                }
6633                                              else
6634                                                {
6635                                                  if (((word >> 29) & 0x1) == 0)
6636                                                    {
6637                                                      /* 33222222222211111111110000000000
6638                                                         10987654321098765432109876543210
6639                                                         xxxxxxxxxx100001xxxxx1xx011100xx
6640                                                         add.  */
6641                                                      return 238;
6642                                                    }
6643                                                  else
6644                                                    {
6645                                                      /* 33222222222211111111110000000000
6646                                                         10987654321098765432109876543210
6647                                                         xxxxxxxxxx100001xxxxx1xx011101xx
6648                                                         sub.  */
6649                                                      return 278;
6650                                                    }
6651                                                }
6652                                            }
6653                                          else
6654                                            {
6655                                              if (((word >> 15) & 0x1) == 0)
6656                                                {
6657                                                  if (((word >> 29) & 0x1) == 0)
6658                                                    {
6659                                                      /* 33222222222211111111110000000000
6660                                                         10987654321098765432109876543210
6661                                                         xxxxxxxxxx100010xxxxx1xx011100xx
6662                                                         sshl.  */
6663                                                      return 230;
6664                                                    }
6665                                                  else
6666                                                    {
6667                                                      /* 33222222222211111111110000000000
6668                                                         10987654321098765432109876543210
6669                                                         xxxxxxxxxx100010xxxxx1xx011101xx
6670                                                         ushl.  */
6671                                                      return 270;
6672                                                    }
6673                                                }
6674                                              else
6675                                                {
6676                                                  if (((word >> 23) & 0x1) == 0)
6677                                                    {
6678                                                      if (((word >> 29) & 0x1) == 0)
6679                                                        {
6680                                                          /* 33222222222211111111110000000000
6681                                                             10987654321098765432109876543210
6682                                                             xxxxxxxxxx100011xxxxx1x0011100xx
6683                                                             fmaxnm.  */
6684                                                          return 246;
6685                                                        }
6686                                                      else
6687                                                        {
6688                                                          /* 33222222222211111111110000000000
6689                                                             10987654321098765432109876543210
6690                                                             xxxxxxxxxx100011xxxxx1x0011101xx
6691                                                             fmaxnmp.  */
6692                                                          return 285;
6693                                                        }
6694                                                    }
6695                                                  else
6696                                                    {
6697                                                      if (((word >> 29) & 0x1) == 0)
6698                                                        {
6699                                                          /* 33222222222211111111110000000000
6700                                                             10987654321098765432109876543210
6701                                                             xxxxxxxxxx100011xxxxx1x1011100xx
6702                                                             fminnm.  */
6703                                                          return 255;
6704                                                        }
6705                                                      else
6706                                                        {
6707                                                          /* 33222222222211111111110000000000
6708                                                             10987654321098765432109876543210
6709                                                             xxxxxxxxxx100011xxxxx1x1011101xx
6710                                                             fminnmp.  */
6711                                                          return 294;
6712                                                        }
6713                                                    }
6714                                                }
6715                                            }
6716                                        }
6717                                      else
6718                                        {
6719                                          if (((word >> 14) & 0x1) == 0)
6720                                            {
6721                                              if (((word >> 15) & 0x1) == 0)
6722                                                {
6723                                                  if (((word >> 29) & 0x1) == 0)
6724                                                    {
6725                                                      /* 33222222222211111111110000000000
6726                                                         10987654321098765432109876543210
6727                                                         xxxxxxxxxx100100xxxxx1xx011100xx
6728                                                         shsub.  */
6729                                                      return 226;
6730                                                    }
6731                                                  else
6732                                                    {
6733                                                      /* 33222222222211111111110000000000
6734                                                         10987654321098765432109876543210
6735                                                         xxxxxxxxxx100100xxxxx1xx011101xx
6736                                                         uhsub.  */
6737                                                      return 266;
6738                                                    }
6739                                                }
6740                                              else
6741                                                {
6742                                                  if (((word >> 29) & 0x1) == 0)
6743                                                    {
6744                                                      /* 33222222222211111111110000000000
6745                                                         10987654321098765432109876543210
6746                                                         xxxxxxxxxx100101xxxxx1xx011100xx
6747                                                         smaxp.  */
6748                                                      return 242;
6749                                                    }
6750                                                  else
6751                                                    {
6752                                                      /* 33222222222211111111110000000000
6753                                                         10987654321098765432109876543210
6754                                                         xxxxxxxxxx100101xxxxx1xx011101xx
6755                                                         umaxp.  */
6756                                                      return 282;
6757                                                    }
6758                                                }
6759                                            }
6760                                          else
6761                                            {
6762                                              if (((word >> 15) & 0x1) == 0)
6763                                                {
6764                                                  if (((word >> 29) & 0x1) == 0)
6765                                                    {
6766                                                      /* 33222222222211111111110000000000
6767                                                         10987654321098765432109876543210
6768                                                         xxxxxxxxxx100110xxxxx1xx011100xx
6769                                                         smax.  */
6770                                                      return 234;
6771                                                    }
6772                                                  else
6773                                                    {
6774                                                      /* 33222222222211111111110000000000
6775                                                         10987654321098765432109876543210
6776                                                         xxxxxxxxxx100110xxxxx1xx011101xx
6777                                                         umax.  */
6778                                                      return 274;
6779                                                    }
6780                                                }
6781                                              else
6782                                                {
6783                                                  if (((word >> 23) & 0x1) == 0)
6784                                                    {
6785                                                      if (((word >> 29) & 0x1) == 0)
6786                                                        {
6787                                                          /* 33222222222211111111110000000000
6788                                                             10987654321098765432109876543210
6789                                                             xxxxxxxxxx100111xxxxx1x0011100xx
6790                                                             fcmeq.  */
6791                                                          return 250;
6792                                                        }
6793                                                      else
6794                                                        {
6795                                                          /* 33222222222211111111110000000000
6796                                                             10987654321098765432109876543210
6797                                                             xxxxxxxxxx100111xxxxx1x0011101xx
6798                                                             fcmge.  */
6799                                                          return 288;
6800                                                        }
6801                                                    }
6802                                                  else
6803                                                    {
6804                                                      /* 33222222222211111111110000000000
6805                                                         10987654321098765432109876543210
6806                                                         xxxxxxxxxx100111xxxxx1x101110xxx
6807                                                         fcmgt.  */
6808                                                      return 296;
6809                                                    }
6810                                                }
6811                                            }
6812                                        }
6813                                    }
6814                                  else
6815                                    {
6816                                      if (((word >> 13) & 0x1) == 0)
6817                                        {
6818                                          if (((word >> 14) & 0x1) == 0)
6819                                            {
6820                                              if (((word >> 15) & 0x1) == 0)
6821                                                {
6822                                                  if (((word >> 29) & 0x1) == 0)
6823                                                    {
6824                                                      /* 33222222222211111111110000000000
6825                                                         10987654321098765432109876543210
6826                                                         xxxxxxxxxx101000xxxxx1xx011100xx
6827                                                         srhadd.  */
6828                                                      return 225;
6829                                                    }
6830                                                  else
6831                                                    {
6832                                                      /* 33222222222211111111110000000000
6833                                                         10987654321098765432109876543210
6834                                                         xxxxxxxxxx101000xxxxx1xx011101xx
6835                                                         urhadd.  */
6836                                                      return 265;
6837                                                    }
6838                                                }
6839                                              else
6840                                                {
6841                                                  if (((word >> 29) & 0x1) == 0)
6842                                                    {
6843                                                      /* 33222222222211111111110000000000
6844                                                         10987654321098765432109876543210
6845                                                         xxxxxxxxxx101001xxxxx1xx011100xx
6846                                                         mla.  */
6847                                                      return 240;
6848                                                    }
6849                                                  else
6850                                                    {
6851                                                      /* 33222222222211111111110000000000
6852                                                         10987654321098765432109876543210
6853                                                         xxxxxxxxxx101001xxxxx1xx011101xx
6854                                                         mls.  */
6855                                                      return 280;
6856                                                    }
6857                                                }
6858                                            }
6859                                          else
6860                                            {
6861                                              if (((word >> 15) & 0x1) == 0)
6862                                                {
6863                                                  if (((word >> 29) & 0x1) == 0)
6864                                                    {
6865                                                      /* 33222222222211111111110000000000
6866                                                         10987654321098765432109876543210
6867                                                         xxxxxxxxxx101010xxxxx1xx011100xx
6868                                                         srshl.  */
6869                                                      return 232;
6870                                                    }
6871                                                  else
6872                                                    {
6873                                                      /* 33222222222211111111110000000000
6874                                                         10987654321098765432109876543210
6875                                                         xxxxxxxxxx101010xxxxx1xx011101xx
6876                                                         urshl.  */
6877                                                      return 272;
6878                                                    }
6879                                                }
6880                                              else
6881                                                {
6882                                                  if (((word >> 23) & 0x1) == 0)
6883                                                    {
6884                                                      if (((word >> 29) & 0x1) == 0)
6885                                                        {
6886                                                          /* 33222222222211111111110000000000
6887                                                             10987654321098765432109876543210
6888                                                             xxxxxxxxxx101011xxxxx1x0011100xx
6889                                                             fadd.  */
6890                                                          return 248;
6891                                                        }
6892                                                      else
6893                                                        {
6894                                                          /* 33222222222211111111110000000000
6895                                                             10987654321098765432109876543210
6896                                                             xxxxxxxxxx101011xxxxx1x0011101xx
6897                                                             faddp.  */
6898                                                          return 286;
6899                                                        }
6900                                                    }
6901                                                  else
6902                                                    {
6903                                                      if (((word >> 29) & 0x1) == 0)
6904                                                        {
6905                                                          /* 33222222222211111111110000000000
6906                                                             10987654321098765432109876543210
6907                                                             xxxxxxxxxx101011xxxxx1x1011100xx
6908                                                             fsub.  */
6909                                                          return 257;
6910                                                        }
6911                                                      else
6912                                                        {
6913                                                          /* 33222222222211111111110000000000
6914                                                             10987654321098765432109876543210
6915                                                             xxxxxxxxxx101011xxxxx1x1011101xx
6916                                                             fabd.  */
6917                                                          return 295;
6918                                                        }
6919                                                    }
6920                                                }
6921                                            }
6922                                        }
6923                                      else
6924                                        {
6925                                          if (((word >> 14) & 0x1) == 0)
6926                                            {
6927                                              if (((word >> 15) & 0x1) == 0)
6928                                                {
6929                                                  if (((word >> 29) & 0x1) == 0)
6930                                                    {
6931                                                      /* 33222222222211111111110000000000
6932                                                         10987654321098765432109876543210
6933                                                         xxxxxxxxxx101100xxxxx1xx011100xx
6934                                                         cmgt.  */
6935                                                      return 228;
6936                                                    }
6937                                                  else
6938                                                    {
6939                                                      /* 33222222222211111111110000000000
6940                                                         10987654321098765432109876543210
6941                                                         xxxxxxxxxx101100xxxxx1xx011101xx
6942                                                         cmhi.  */
6943                                                      return 268;
6944                                                    }
6945                                                }
6946                                              else
6947                                                {
6948                                                  if (((word >> 29) & 0x1) == 0)
6949                                                    {
6950                                                      /* 33222222222211111111110000000000
6951                                                         10987654321098765432109876543210
6952                                                         xxxxxxxxxx101101xxxxx1xx011100xx
6953                                                         sqdmulh.  */
6954                                                      return 244;
6955                                                    }
6956                                                  else
6957                                                    {
6958                                                      /* 33222222222211111111110000000000
6959                                                         10987654321098765432109876543210
6960                                                         xxxxxxxxxx101101xxxxx1xx011101xx
6961                                                         sqrdmulh.  */
6962                                                      return 284;
6963                                                    }
6964                                                }
6965                                            }
6966                                          else
6967                                            {
6968                                              if (((word >> 15) & 0x1) == 0)
6969                                                {
6970                                                  if (((word >> 29) & 0x1) == 0)
6971                                                    {
6972                                                      /* 33222222222211111111110000000000
6973                                                         10987654321098765432109876543210
6974                                                         xxxxxxxxxx101110xxxxx1xx011100xx
6975                                                         sabd.  */
6976                                                      return 236;
6977                                                    }
6978                                                  else
6979                                                    {
6980                                                      /* 33222222222211111111110000000000
6981                                                         10987654321098765432109876543210
6982                                                         xxxxxxxxxx101110xxxxx1xx011101xx
6983                                                         uabd.  */
6984                                                      return 276;
6985                                                    }
6986                                                }
6987                                              else
6988                                                {
6989                                                  if (((word >> 23) & 0x1) == 0)
6990                                                    {
6991                                                      if (((word >> 29) & 0x1) == 0)
6992                                                        {
6993                                                          /* 33222222222211111111110000000000
6994                                                             10987654321098765432109876543210
6995                                                             xxxxxxxxxx101111xxxxx1x0011100xx
6996                                                             fmax.  */
6997                                                          return 251;
6998                                                        }
6999                                                      else
7000                                                        {
7001                                                          /* 33222222222211111111110000000000
7002                                                             10987654321098765432109876543210
7003                                                             xxxxxxxxxx101111xxxxx1x0011101xx
7004                                                             fmaxp.  */
7005                                                          return 290;
7006                                                        }
7007                                                    }
7008                                                  else
7009                                                    {
7010                                                      if (((word >> 29) & 0x1) == 0)
7011                                                        {
7012                                                          /* 33222222222211111111110000000000
7013                                                             10987654321098765432109876543210
7014                                                             xxxxxxxxxx101111xxxxx1x1011100xx
7015                                                             fmin.  */
7016                                                          return 258;
7017                                                        }
7018                                                      else
7019                                                        {
7020                                                          /* 33222222222211111111110000000000
7021                                                             10987654321098765432109876543210
7022                                                             xxxxxxxxxx101111xxxxx1x1011101xx
7023                                                             fminp.  */
7024                                                          return 298;
7025                                                        }
7026                                                    }
7027                                                }
7028                                            }
7029                                        }
7030                                    }
7031                                }
7032                              else
7033                                {
7034                                  if (((word >> 29) & 0x1) == 0)
7035                                    {
7036                                      if (((word >> 30) & 0x1) == 0)
7037                                        {
7038                                          if (((word >> 4) & 0x1) == 0)
7039                                            {
7040                                              /* 33222222222211111111110000000000
7041                                                 10987654321098765432109876543210
7042                                                 xxxx0xxxxx10xxxxxxxxx1xx0111100x
7043                                                 fccmp.  */
7044                                              return 624;
7045                                            }
7046                                          else
7047                                            {
7048                                              /* 33222222222211111111110000000000
7049                                                 10987654321098765432109876543210
7050                                                 xxxx1xxxxx10xxxxxxxxx1xx0111100x
7051                                                 fccmpe.  */
7052                                              return 625;
7053                                            }
7054                                        }
7055                                      else
7056                                        {
7057                                          if (((word >> 12) & 0x1) == 0)
7058                                            {
7059                                              if (((word >> 13) & 0x1) == 0)
7060                                                {
7061                                                  if (((word >> 14) & 0x1) == 0)
7062                                                    {
7063                                                      /* 33222222222211111111110000000000
7064                                                         10987654321098765432109876543210
7065                                                         xxxxxxxxxx10000xxxxxx1xx0111101x
7066                                                         add.  */
7067                                                      return 457;
7068                                                    }
7069                                                  else
7070                                                    {
7071                                                      /* 33222222222211111111110000000000
7072                                                         10987654321098765432109876543210
7073                                                         xxxxxxxxxx10001xxxxxx1xx0111101x
7074                                                         sshl.  */
7075                                                      return 455;
7076                                                    }
7077                                                }
7078                                              else
7079                                                {
7080                                                  /* 33222222222211111111110000000000
7081                                                     10987654321098765432109876543210
7082                                                     xxxxxxxxxx1001xxxxxxx1xx0111101x
7083                                                     fcmeq.  */
7084                                                  return 450;
7085                                                }
7086                                            }
7087                                          else
7088                                            {
7089                                              if (((word >> 13) & 0x1) == 0)
7090                                                {
7091                                                  /* 33222222222211111111110000000000
7092                                                     10987654321098765432109876543210
7093                                                     xxxxxxxxxx1010xxxxxxx1xx0111101x
7094                                                     srshl.  */
7095                                                  return 456;
7096                                                }
7097                                              else
7098                                                {
7099                                                  if (((word >> 15) & 0x1) == 0)
7100                                                    {
7101                                                      /* 33222222222211111111110000000000
7102                                                         10987654321098765432109876543210
7103                                                         xxxxxxxxxx1011x0xxxxx1xx0111101x
7104                                                         cmgt.  */
7105                                                      return 453;
7106                                                    }
7107                                                  else
7108                                                    {
7109                                                      /* 33222222222211111111110000000000
7110                                                         10987654321098765432109876543210
7111                                                         xxxxxxxxxx1011x1xxxxx1xx0111101x
7112                                                         sqdmulh.  */
7113                                                      return 448;
7114                                                    }
7115                                                }
7116                                            }
7117                                        }
7118                                    }
7119                                  else
7120                                    {
7121                                      if (((word >> 12) & 0x1) == 0)
7122                                        {
7123                                          if (((word >> 13) & 0x1) == 0)
7124                                            {
7125                                              if (((word >> 14) & 0x1) == 0)
7126                                                {
7127                                                  /* 33222222222211111111110000000000
7128                                                     10987654321098765432109876543210
7129                                                     xxxxxxxxxx10000xxxxxx1xx011111xx
7130                                                     sub.  */
7131                                                  return 473;
7132                                                }
7133                                              else
7134                                                {
7135                                                  /* 33222222222211111111110000000000
7136                                                     10987654321098765432109876543210
7137                                                     xxxxxxxxxx10001xxxxxx1xx011111xx
7138                                                     ushl.  */
7139                                                  return 471;
7140                                                }
7141                                            }
7142                                          else
7143                                            {
7144                                              if (((word >> 23) & 0x1) == 0)
7145                                                {
7146                                                  /* 33222222222211111111110000000000
7147                                                     10987654321098765432109876543210
7148                                                     xxxxxxxxxx1001xxxxxxx1x0011111xx
7149                                                     fcmge.  */
7150                                                  return 464;
7151                                                }
7152                                              else
7153                                                {
7154                                                  /* 33222222222211111111110000000000
7155                                                     10987654321098765432109876543210
7156                                                     xxxxxxxxxx1001xxxxxxx1x1011111xx
7157                                                     fcmgt.  */
7158                                                  return 467;
7159                                                }
7160                                            }
7161                                        }
7162                                      else
7163                                        {
7164                                          if (((word >> 13) & 0x1) == 0)
7165                                            {
7166                                              if (((word >> 15) & 0x1) == 0)
7167                                                {
7168                                                  /* 33222222222211111111110000000000
7169                                                     10987654321098765432109876543210
7170                                                     xxxxxxxxxx1010x0xxxxx1xx011111xx
7171                                                     urshl.  */
7172                                                  return 472;
7173                                                }
7174                                              else
7175                                                {
7176                                                  /* 33222222222211111111110000000000
7177                                                     10987654321098765432109876543210
7178                                                     xxxxxxxxxx1010x1xxxxx1xx011111xx
7179                                                     fabd.  */
7180                                                  return 466;
7181                                                }
7182                                            }
7183                                          else
7184                                            {
7185                                              if (((word >> 15) & 0x1) == 0)
7186                                                {
7187                                                  /* 33222222222211111111110000000000
7188                                                     10987654321098765432109876543210
7189                                                     xxxxxxxxxx1011x0xxxxx1xx011111xx
7190                                                     cmhi.  */
7191                                                  return 469;
7192                                                }
7193                                              else
7194                                                {
7195                                                  /* 33222222222211111111110000000000
7196                                                     10987654321098765432109876543210
7197                                                     xxxxxxxxxx1011x1xxxxx1xx011111xx
7198                                                     sqrdmulh.  */
7199                                                  return 463;
7200                                                }
7201                                            }
7202                                        }
7203                                    }
7204                                }
7205                            }
7206                          else
7207                            {
7208                              if (((word >> 28) & 0x1) == 0)
7209                                {
7210                                  if (((word >> 12) & 0x1) == 0)
7211                                    {
7212                                      if (((word >> 13) & 0x1) == 0)
7213                                        {
7214                                          if (((word >> 14) & 0x1) == 0)
7215                                            {
7216                                              if (((word >> 15) & 0x1) == 0)
7217                                                {
7218                                                  if (((word >> 29) & 0x1) == 0)
7219                                                    {
7220                                                      /* 33222222222211111111110000000000
7221                                                         10987654321098765432109876543210
7222                                                         xxxxxxxxxx110000xxxxx1xx011100xx
7223                                                         sqadd.  */
7224                                                      return 224;
7225                                                    }
7226                                                  else
7227                                                    {
7228                                                      /* 33222222222211111111110000000000
7229                                                         10987654321098765432109876543210
7230                                                         xxxxxxxxxx110000xxxxx1xx011101xx
7231                                                         uqadd.  */
7232                                                      return 264;
7233                                                    }
7234                                                }
7235                                              else
7236                                                {
7237                                                  if (((word >> 29) & 0x1) == 0)
7238                                                    {
7239                                                      /* 33222222222211111111110000000000
7240                                                         10987654321098765432109876543210
7241                                                         xxxxxxxxxx110001xxxxx1xx011100xx
7242                                                         cmtst.  */
7243                                                      return 239;
7244                                                    }
7245                                                  else
7246                                                    {
7247                                                      /* 33222222222211111111110000000000
7248                                                         10987654321098765432109876543210
7249                                                         xxxxxxxxxx110001xxxxx1xx011101xx
7250                                                         cmeq.  */
7251                                                      return 279;
7252                                                    }
7253                                                }
7254                                            }
7255                                          else
7256                                            {
7257                                              if (((word >> 15) & 0x1) == 0)
7258                                                {
7259                                                  if (((word >> 29) & 0x1) == 0)
7260                                                    {
7261                                                      /* 33222222222211111111110000000000
7262                                                         10987654321098765432109876543210
7263                                                         xxxxxxxxxx110010xxxxx1xx011100xx
7264                                                         sqshl.  */
7265                                                      return 231;
7266                                                    }
7267                                                  else
7268                                                    {
7269                                                      /* 33222222222211111111110000000000
7270                                                         10987654321098765432109876543210
7271                                                         xxxxxxxxxx110010xxxxx1xx011101xx
7272                                                         uqshl.  */
7273                                                      return 271;
7274                                                    }
7275                                                }
7276                                              else
7277                                                {
7278                                                  if (((word >> 23) & 0x1) == 0)
7279                                                    {
7280                                                      /* 33222222222211111111110000000000
7281                                                         10987654321098765432109876543210
7282                                                         xxxxxxxxxx110011xxxxx1x001110xxx
7283                                                         fmla.  */
7284                                                      return 247;
7285                                                    }
7286                                                  else
7287                                                    {
7288                                                      /* 33222222222211111111110000000000
7289                                                         10987654321098765432109876543210
7290                                                         xxxxxxxxxx110011xxxxx1x101110xxx
7291                                                         fmls.  */
7292                                                      return 256;
7293                                                    }
7294                                                }
7295                                            }
7296                                        }
7297                                      else
7298                                        {
7299                                          if (((word >> 14) & 0x1) == 0)
7300                                            {
7301                                              if (((word >> 15) & 0x1) == 0)
7302                                                {
7303                                                  if (((word >> 29) & 0x1) == 0)
7304                                                    {
7305                                                      /* 33222222222211111111110000000000
7306                                                         10987654321098765432109876543210
7307                                                         xxxxxxxxxx110100xxxxx1xx011100xx
7308                                                         sqsub.  */
7309                                                      return 227;
7310                                                    }
7311                                                  else
7312                                                    {
7313                                                      /* 33222222222211111111110000000000
7314                                                         10987654321098765432109876543210
7315                                                         xxxxxxxxxx110100xxxxx1xx011101xx
7316                                                         uqsub.  */
7317                                                      return 267;
7318                                                    }
7319                                                }
7320                                              else
7321                                                {
7322                                                  if (((word >> 29) & 0x1) == 0)
7323                                                    {
7324                                                      /* 33222222222211111111110000000000
7325                                                         10987654321098765432109876543210
7326                                                         xxxxxxxxxx110101xxxxx1xx011100xx
7327                                                         sminp.  */
7328                                                      return 243;
7329                                                    }
7330                                                  else
7331                                                    {
7332                                                      /* 33222222222211111111110000000000
7333                                                         10987654321098765432109876543210
7334                                                         xxxxxxxxxx110101xxxxx1xx011101xx
7335                                                         uminp.  */
7336                                                      return 283;
7337                                                    }
7338                                                }
7339                                            }
7340                                          else
7341                                            {
7342                                              if (((word >> 15) & 0x1) == 0)
7343                                                {
7344                                                  if (((word >> 29) & 0x1) == 0)
7345                                                    {
7346                                                      /* 33222222222211111111110000000000
7347                                                         10987654321098765432109876543210
7348                                                         xxxxxxxxxx110110xxxxx1xx011100xx
7349                                                         smin.  */
7350                                                      return 235;
7351                                                    }
7352                                                  else
7353                                                    {
7354                                                      /* 33222222222211111111110000000000
7355                                                         10987654321098765432109876543210
7356                                                         xxxxxxxxxx110110xxxxx1xx011101xx
7357                                                         umin.  */
7358                                                      return 275;
7359                                                    }
7360                                                }
7361                                              else
7362                                                {
7363                                                  if (((word >> 23) & 0x1) == 0)
7364                                                    {
7365                                                      /* 33222222222211111111110000000000
7366                                                         10987654321098765432109876543210
7367                                                         xxxxxxxxxx110111xxxxx1x001110xxx
7368                                                         facge.  */
7369                                                      return 289;
7370                                                    }
7371                                                  else
7372                                                    {
7373                                                      /* 33222222222211111111110000000000
7374                                                         10987654321098765432109876543210
7375                                                         xxxxxxxxxx110111xxxxx1x101110xxx
7376                                                         facgt.  */
7377                                                      return 297;
7378                                                    }
7379                                                }
7380                                            }
7381                                        }
7382                                    }
7383                                  else
7384                                    {
7385                                      if (((word >> 13) & 0x1) == 0)
7386                                        {
7387                                          if (((word >> 14) & 0x1) == 0)
7388                                            {
7389                                              if (((word >> 15) & 0x1) == 0)
7390                                                {
7391                                                  if (((word >> 22) & 0x1) == 0)
7392                                                    {
7393                                                      if (((word >> 23) & 0x1) == 0)
7394                                                        {
7395                                                          if (((word >> 29) & 0x1) == 0)
7396                                                            {
7397                                                              /* 33222222222211111111110000000000
7398                                                                 10987654321098765432109876543210
7399                                                                 xxxxxxxxxx111000xxxxx100011100xx
7400                                                                 and.  */
7401                                                              return 253;
7402                                                            }
7403                                                          else
7404                                                            {
7405                                                              /* 33222222222211111111110000000000
7406                                                                 10987654321098765432109876543210
7407                                                                 xxxxxxxxxx111000xxxxx100011101xx
7408                                                                 eor.  */
7409                                                              return 292;
7410                                                            }
7411                                                        }
7412                                                      else
7413                                                        {
7414                                                          if (((word >> 29) & 0x1) == 0)
7415                                                            {
7416                                                              /* 33222222222211111111110000000000
7417                                                                 10987654321098765432109876543210
7418                                                                 xxxxxxxxxx111000xxxxx101011100xx
7419                                                                 orr.  */
7420                                                              return 260;
7421                                                            }
7422                                                          else
7423                                                            {
7424                                                              /* 33222222222211111111110000000000
7425                                                                 10987654321098765432109876543210
7426                                                                 xxxxxxxxxx111000xxxxx101011101xx
7427                                                                 bit.  */
7428                                                              return 299;
7429                                                            }
7430                                                        }
7431                                                    }
7432                                                  else
7433                                                    {
7434                                                      if (((word >> 23) & 0x1) == 0)
7435                                                        {
7436                                                          if (((word >> 29) & 0x1) == 0)
7437                                                            {
7438                                                              /* 33222222222211111111110000000000
7439                                                                 10987654321098765432109876543210
7440                                                                 xxxxxxxxxx111000xxxxx110011100xx
7441                                                                 bic.  */
7442                                                              return 254;
7443                                                            }
7444                                                          else
7445                                                            {
7446                                                              /* 33222222222211111111110000000000
7447                                                                 10987654321098765432109876543210
7448                                                                 xxxxxxxxxx111000xxxxx110011101xx
7449                                                                 bsl.  */
7450                                                              return 293;
7451                                                            }
7452                                                        }
7453                                                      else
7454                                                        {
7455                                                          if (((word >> 29) & 0x1) == 0)
7456                                                            {
7457                                                              /* 33222222222211111111110000000000
7458                                                                 10987654321098765432109876543210
7459                                                                 xxxxxxxxxx111000xxxxx111011100xx
7460                                                                 orn.  */
7461                                                              return 262;
7462                                                            }
7463                                                          else
7464                                                            {
7465                                                              /* 33222222222211111111110000000000
7466                                                                 10987654321098765432109876543210
7467                                                                 xxxxxxxxxx111000xxxxx111011101xx
7468                                                                 bif.  */
7469                                                              return 300;
7470                                                            }
7471                                                        }
7472                                                    }
7473                                                }
7474                                              else
7475                                                {
7476                                                  if (((word >> 29) & 0x1) == 0)
7477                                                    {
7478                                                      /* 33222222222211111111110000000000
7479                                                         10987654321098765432109876543210
7480                                                         xxxxxxxxxx111001xxxxx1xx011100xx
7481                                                         mul.  */
7482                                                      return 241;
7483                                                    }
7484                                                  else
7485                                                    {
7486                                                      /* 33222222222211111111110000000000
7487                                                         10987654321098765432109876543210
7488                                                         xxxxxxxxxx111001xxxxx1xx011101xx
7489                                                         pmul.  */
7490                                                      return 281;
7491                                                    }
7492                                                }
7493                                            }
7494                                          else
7495                                            {
7496                                              if (((word >> 15) & 0x1) == 0)
7497                                                {
7498                                                  if (((word >> 29) & 0x1) == 0)
7499                                                    {
7500                                                      /* 33222222222211111111110000000000
7501                                                         10987654321098765432109876543210
7502                                                         xxxxxxxxxx111010xxxxx1xx011100xx
7503                                                         sqrshl.  */
7504                                                      return 233;
7505                                                    }
7506                                                  else
7507                                                    {
7508                                                      /* 33222222222211111111110000000000
7509                                                         10987654321098765432109876543210
7510                                                         xxxxxxxxxx111010xxxxx1xx011101xx
7511                                                         uqrshl.  */
7512                                                      return 273;
7513                                                    }
7514                                                }
7515                                              else
7516                                                {
7517                                                  if (((word >> 29) & 0x1) == 0)
7518                                                    {
7519                                                      /* 33222222222211111111110000000000
7520                                                         10987654321098765432109876543210
7521                                                         xxxxxxxxxx111011xxxxx1xx011100xx
7522                                                         fmulx.  */
7523                                                      return 249;
7524                                                    }
7525                                                  else
7526                                                    {
7527                                                      /* 33222222222211111111110000000000
7528                                                         10987654321098765432109876543210
7529                                                         xxxxxxxxxx111011xxxxx1xx011101xx
7530                                                         fmul.  */
7531                                                      return 287;
7532                                                    }
7533                                                }
7534                                            }
7535                                        }
7536                                      else
7537                                        {
7538                                          if (((word >> 14) & 0x1) == 0)
7539                                            {
7540                                              if (((word >> 15) & 0x1) == 0)
7541                                                {
7542                                                  if (((word >> 29) & 0x1) == 0)
7543                                                    {
7544                                                      /* 33222222222211111111110000000000
7545                                                         10987654321098765432109876543210
7546                                                         xxxxxxxxxx111100xxxxx1xx011100xx
7547                                                         cmge.  */
7548                                                      return 229;
7549                                                    }
7550                                                  else
7551                                                    {
7552                                                      /* 33222222222211111111110000000000
7553                                                         10987654321098765432109876543210
7554                                                         xxxxxxxxxx111100xxxxx1xx011101xx
7555                                                         cmhs.  */
7556                                                      return 269;
7557                                                    }
7558                                                }
7559                                              else
7560                                                {
7561                                                  /* 33222222222211111111110000000000
7562                                                     10987654321098765432109876543210
7563                                                     xxxxxxxxxx111101xxxxx1xx01110xxx
7564                                                     addp.  */
7565                                                  return 245;
7566                                                }
7567                                            }
7568                                          else
7569                                            {
7570                                              if (((word >> 15) & 0x1) == 0)
7571                                                {
7572                                                  if (((word >> 29) & 0x1) == 0)
7573                                                    {
7574                                                      /* 33222222222211111111110000000000
7575                                                         10987654321098765432109876543210
7576                                                         xxxxxxxxxx111110xxxxx1xx011100xx
7577                                                         saba.  */
7578                                                      return 237;
7579                                                    }
7580                                                  else
7581                                                    {
7582                                                      /* 33222222222211111111110000000000
7583                                                         10987654321098765432109876543210
7584                                                         xxxxxxxxxx111110xxxxx1xx011101xx
7585                                                         uaba.  */
7586                                                      return 277;
7587                                                    }
7588                                                }
7589                                              else
7590                                                {
7591                                                  if (((word >> 23) & 0x1) == 0)
7592                                                    {
7593                                                      if (((word >> 29) & 0x1) == 0)
7594                                                        {
7595                                                          /* 33222222222211111111110000000000
7596                                                             10987654321098765432109876543210
7597                                                             xxxxxxxxxx111111xxxxx1x0011100xx
7598                                                             frecps.  */
7599                                                          return 252;
7600                                                        }
7601                                                      else
7602                                                        {
7603                                                          /* 33222222222211111111110000000000
7604                                                             10987654321098765432109876543210
7605                                                             xxxxxxxxxx111111xxxxx1x0011101xx
7606                                                             fdiv.  */
7607                                                          return 291;
7608                                                        }
7609                                                    }
7610                                                  else
7611                                                    {
7612                                                      /* 33222222222211111111110000000000
7613                                                         10987654321098765432109876543210
7614                                                         xxxxxxxxxx111111xxxxx1x101110xxx
7615                                                         frsqrts.  */
7616                                                      return 259;
7617                                                    }
7618                                                }
7619                                            }
7620                                        }
7621                                    }
7622                                }
7623                              else
7624                                {
7625                                  if (((word >> 29) & 0x1) == 0)
7626                                    {
7627                                      if (((word >> 30) & 0x1) == 0)
7628                                        {
7629                                          /* 33222222222211111111110000000000
7630                                             10987654321098765432109876543210
7631                                             xxxxxxxxxx11xxxxxxxxx1xx0111100x
7632                                             fcsel.  */
7633                                          return 656;
7634                                        }
7635                                      else
7636                                        {
7637                                          if (((word >> 12) & 0x1) == 0)
7638                                            {
7639                                              if (((word >> 13) & 0x1) == 0)
7640                                                {
7641                                                  if (((word >> 14) & 0x1) == 0)
7642                                                    {
7643                                                      if (((word >> 15) & 0x1) == 0)
7644                                                        {
7645                                                          /* 33222222222211111111110000000000
7646                                                             10987654321098765432109876543210
7647                                                             xxxxxxxxxx110000xxxxx1xx0111101x
7648                                                             sqadd.  */
7649                                                          return 444;
7650                                                        }
7651                                                      else
7652                                                        {
7653                                                          /* 33222222222211111111110000000000
7654                                                             10987654321098765432109876543210
7655                                                             xxxxxxxxxx110001xxxxx1xx0111101x
7656                                                             cmtst.  */
7657                                                          return 458;
7658                                                        }
7659                                                    }
7660                                                  else
7661                                                    {
7662                                                      /* 33222222222211111111110000000000
7663                                                         10987654321098765432109876543210
7664                                                         xxxxxxxxxx11001xxxxxx1xx0111101x
7665                                                         sqshl.  */
7666                                                      return 446;
7667                                                    }
7668                                                }
7669                                              else
7670                                                {
7671                                                  /* 33222222222211111111110000000000
7672                                                     10987654321098765432109876543210
7673                                                     xxxxxxxxxx1101xxxxxxx1xx0111101x
7674                                                     sqsub.  */
7675                                                  return 445;
7676                                                }
7677                                            }
7678                                          else
7679                                            {
7680                                              if (((word >> 13) & 0x1) == 0)
7681                                                {
7682                                                  if (((word >> 15) & 0x1) == 0)
7683                                                    {
7684                                                      /* 33222222222211111111110000000000
7685                                                         10987654321098765432109876543210
7686                                                         xxxxxxxxxx1110x0xxxxx1xx0111101x
7687                                                         sqrshl.  */
7688                                                      return 447;
7689                                                    }
7690                                                  else
7691                                                    {
7692                                                      /* 33222222222211111111110000000000
7693                                                         10987654321098765432109876543210
7694                                                         xxxxxxxxxx1110x1xxxxx1xx0111101x
7695                                                         fmulx.  */
7696                                                      return 449;
7697                                                    }
7698                                                }
7699                                              else
7700                                                {
7701                                                  if (((word >> 14) & 0x1) == 0)
7702                                                    {
7703                                                      /* 33222222222211111111110000000000
7704                                                         10987654321098765432109876543210
7705                                                         xxxxxxxxxx11110xxxxxx1xx0111101x
7706                                                         cmge.  */
7707                                                      return 454;
7708                                                    }
7709                                                  else
7710                                                    {
7711                                                      if (((word >> 23) & 0x1) == 0)
7712                                                        {
7713                                                          /* 33222222222211111111110000000000
7714                                                             10987654321098765432109876543210
7715                                                             xxxxxxxxxx11111xxxxxx1x00111101x
7716                                                             frecps.  */
7717                                                          return 451;
7718                                                        }
7719                                                      else
7720                                                        {
7721                                                          /* 33222222222211111111110000000000
7722                                                             10987654321098765432109876543210
7723                                                             xxxxxxxxxx11111xxxxxx1x10111101x
7724                                                             frsqrts.  */
7725                                                          return 452;
7726                                                        }
7727                                                    }
7728                                                }
7729                                            }
7730                                        }
7731                                    }
7732                                  else
7733                                    {
7734                                      if (((word >> 12) & 0x1) == 0)
7735                                        {
7736                                          if (((word >> 13) & 0x1) == 0)
7737                                            {
7738                                              if (((word >> 14) & 0x1) == 0)
7739                                                {
7740                                                  if (((word >> 15) & 0x1) == 0)
7741                                                    {
7742                                                      /* 33222222222211111111110000000000
7743                                                         10987654321098765432109876543210
7744                                                         xxxxxxxxxx110000xxxxx1xx011111xx
7745                                                         uqadd.  */
7746                                                      return 459;
7747                                                    }
7748                                                  else
7749                                                    {
7750                                                      /* 33222222222211111111110000000000
7751                                                         10987654321098765432109876543210
7752                                                         xxxxxxxxxx110001xxxxx1xx011111xx
7753                                                         cmeq.  */
7754                                                      return 474;
7755                                                    }
7756                                                }
7757                                              else
7758                                                {
7759                                                  /* 33222222222211111111110000000000
7760                                                     10987654321098765432109876543210
7761                                                     xxxxxxxxxx11001xxxxxx1xx011111xx
7762                                                     uqshl.  */
7763                                                  return 461;
7764                                                }
7765                                            }
7766                                          else
7767                                            {
7768                                              if (((word >> 14) & 0x1) == 0)
7769                                                {
7770                                                  /* 33222222222211111111110000000000
7771                                                     10987654321098765432109876543210
7772                                                     xxxxxxxxxx11010xxxxxx1xx011111xx
7773                                                     uqsub.  */
7774                                                  return 460;
7775                                                }
7776                                              else
7777                                                {
7778                                                  if (((word >> 23) & 0x1) == 0)
7779                                                    {
7780                                                      /* 33222222222211111111110000000000
7781                                                         10987654321098765432109876543210
7782                                                         xxxxxxxxxx11011xxxxxx1x0011111xx
7783                                                         facge.  */
7784                                                      return 465;
7785                                                    }
7786                                                  else
7787                                                    {
7788                                                      /* 33222222222211111111110000000000
7789                                                         10987654321098765432109876543210
7790                                                         xxxxxxxxxx11011xxxxxx1x1011111xx
7791                                                         facgt.  */
7792                                                      return 468;
7793                                                    }
7794                                                }
7795                                            }
7796                                        }
7797                                      else
7798                                        {
7799                                          if (((word >> 13) & 0x1) == 0)
7800                                            {
7801                                              /* 33222222222211111111110000000000
7802                                                 10987654321098765432109876543210
7803                                                 xxxxxxxxxx1110xxxxxxx1xx011111xx
7804                                                 uqrshl.  */
7805                                              return 462;
7806                                            }
7807                                          else
7808                                            {
7809                                              /* 33222222222211111111110000000000
7810                                                 10987654321098765432109876543210
7811                                                 xxxxxxxxxx1111xxxxxxx1xx011111xx
7812                                                 cmhs.  */
7813                                              return 470;
7814                                            }
7815                                        }
7816                                    }
7817                                }
7818                            }
7819                        }
7820                    }
7821                }
7822              else
7823                {
7824                  if (((word >> 15) & 0x1) == 0)
7825                    {
7826                      if (((word >> 28) & 0x1) == 0)
7827                        {
7828                          if (((word >> 10) & 0x1) == 0)
7829                            {
7830                              if (((word >> 12) & 0x1) == 0)
7831                                {
7832                                  if (((word >> 13) & 0x1) == 0)
7833                                    {
7834                                      if (((word >> 14) & 0x1) == 0)
7835                                        {
7836                                          /* 33222222222211111111110000000000
7837                                             10987654321098765432109876543210
7838                                             xxxxxxxxxx0x0000xxxxxxxx11110xxx
7839                                             mla.  */
7840                                          return 110;
7841                                        }
7842                                      else
7843                                        {
7844                                          /* 33222222222211111111110000000000
7845                                             10987654321098765432109876543210
7846                                             xxxxxxxxxx0x0010xxxxxxxx11110xxx
7847                                             mls.  */
7848                                          return 113;
7849                                        }
7850                                    }
7851                                  else
7852                                    {
7853                                      if (((word >> 14) & 0x1) == 0)
7854                                        {
7855                                          if (((word >> 29) & 0x1) == 0)
7856                                            {
7857                                              if (((word >> 30) & 0x1) == 0)
7858                                                {
7859                                                  /* 33222222222211111111110000000000
7860                                                     10987654321098765432109876543210
7861                                                     xxxxxxxxxx0x0100xxxxxxxx1111000x
7862                                                     smlal.  */
7863                                                  return 92;
7864                                                }
7865                                              else
7866                                                {
7867                                                  /* 33222222222211111111110000000000
7868                                                     10987654321098765432109876543210
7869                                                     xxxxxxxxxx0x0100xxxxxxxx1111001x
7870                                                     smlal2.  */
7871                                                  return 93;
7872                                                }
7873                                            }
7874                                          else
7875                                            {
7876                                              if (((word >> 30) & 0x1) == 0)
7877                                                {
7878                                                  /* 33222222222211111111110000000000
7879                                                     10987654321098765432109876543210
7880                                                     xxxxxxxxxx0x0100xxxxxxxx1111010x
7881                                                     umlal.  */
7882                                                  return 111;
7883                                                }
7884                                              else
7885                                                {
7886                                                  /* 33222222222211111111110000000000
7887                                                     10987654321098765432109876543210
7888                                                     xxxxxxxxxx0x0100xxxxxxxx1111011x
7889                                                     umlal2.  */
7890                                                  return 112;
7891                                                }
7892                                            }
7893                                        }
7894                                      else
7895                                        {
7896                                          if (((word >> 29) & 0x1) == 0)
7897                                            {
7898                                              if (((word >> 30) & 0x1) == 0)
7899                                                {
7900                                                  /* 33222222222211111111110000000000
7901                                                     10987654321098765432109876543210
7902                                                     xxxxxxxxxx0x0110xxxxxxxx1111000x
7903                                                     smlsl.  */
7904                                                  return 96;
7905                                                }
7906                                              else
7907                                                {
7908                                                  /* 33222222222211111111110000000000
7909                                                     10987654321098765432109876543210
7910                                                     xxxxxxxxxx0x0110xxxxxxxx1111001x
7911                                                     smlsl2.  */
7912                                                  return 97;
7913                                                }
7914                                            }
7915                                          else
7916                                            {
7917                                              if (((word >> 30) & 0x1) == 0)
7918                                                {
7919                                                  /* 33222222222211111111110000000000
7920                                                     10987654321098765432109876543210
7921                                                     xxxxxxxxxx0x0110xxxxxxxx1111010x
7922                                                     umlsl.  */
7923                                                  return 114;
7924                                                }
7925                                              else
7926                                                {
7927                                                  /* 33222222222211111111110000000000
7928                                                     10987654321098765432109876543210
7929                                                     xxxxxxxxxx0x0110xxxxxxxx1111011x
7930                                                     umlsl2.  */
7931                                                  return 115;
7932                                                }
7933                                            }
7934                                        }
7935                                    }
7936                                }
7937                              else
7938                                {
7939                                  if (((word >> 13) & 0x1) == 0)
7940                                    {
7941                                      if (((word >> 14) & 0x1) == 0)
7942                                        {
7943                                          /* 33222222222211111111110000000000
7944                                             10987654321098765432109876543210
7945                                             xxxxxxxxxx0x1000xxxxxxxx11110xxx
7946                                             fmla.  */
7947                                          return 107;
7948                                        }
7949                                      else
7950                                        {
7951                                          /* 33222222222211111111110000000000
7952                                             10987654321098765432109876543210
7953                                             xxxxxxxxxx0x1010xxxxxxxx11110xxx
7954                                             fmls.  */
7955                                          return 108;
7956                                        }
7957                                    }
7958                                  else
7959                                    {
7960                                      if (((word >> 14) & 0x1) == 0)
7961                                        {
7962                                          if (((word >> 30) & 0x1) == 0)
7963                                            {
7964                                              /* 33222222222211111111110000000000
7965                                                 10987654321098765432109876543210
7966                                                 xxxxxxxxxx0x1100xxxxxxxx11110x0x
7967                                                 sqdmlal.  */
7968                                              return 94;
7969                                            }
7970                                          else
7971                                            {
7972                                              /* 33222222222211111111110000000000
7973                                                 10987654321098765432109876543210
7974                                                 xxxxxxxxxx0x1100xxxxxxxx11110x1x
7975                                                 sqdmlal2.  */
7976                                              return 95;
7977                                            }
7978                                        }
7979                                      else
7980                                        {
7981                                          if (((word >> 30) & 0x1) == 0)
7982                                            {
7983                                              /* 33222222222211111111110000000000
7984                                                 10987654321098765432109876543210
7985                                                 xxxxxxxxxx0x1110xxxxxxxx11110x0x
7986                                                 sqdmlsl.  */
7987                                              return 98;
7988                                            }
7989                                          else
7990                                            {
7991                                              /* 33222222222211111111110000000000
7992                                                 10987654321098765432109876543210
7993                                                 xxxxxxxxxx0x1110xxxxxxxx11110x1x
7994                                                 sqdmlsl2.  */
7995                                              return 99;
7996                                            }
7997                                        }
7998                                    }
7999                                }
8000                            }
8001                          else
8002                            {
8003                              if (((word >> 12) & 0x1) == 0)
8004                                {
8005                                  if (((word >> 29) & 0x1) == 0)
8006                                    {
8007                                      /* 33222222222211111111110000000000
8008                                         10987654321098765432109876543210
8009                                         xxxxxxxxxx1x0xx0xxxxxxxx111100xx
8010                                         movi.  */
8011                                      return 122;
8012                                    }
8013                                  else
8014                                    {
8015                                      /* 33222222222211111111110000000000
8016                                         10987654321098765432109876543210
8017                                         xxxxxxxxxx1x0xx0xxxxxxxx111101xx
8018                                         mvni.  */
8019                                      return 129;
8020                                    }
8021                                }
8022                              else
8023                                {
8024                                  if (((word >> 29) & 0x1) == 0)
8025                                    {
8026                                      /* 33222222222211111111110000000000
8027                                         10987654321098765432109876543210
8028                                         xxxxxxxxxx1x1xx0xxxxxxxx111100xx
8029                                         orr.  */
8030                                      return 123;
8031                                    }
8032                                  else
8033                                    {
8034                                      /* 33222222222211111111110000000000
8035                                         10987654321098765432109876543210
8036                                         xxxxxxxxxx1x1xx0xxxxxxxx111101xx
8037                                         bic.  */
8038                                      return 130;
8039                                    }
8040                                }
8041                            }
8042                        }
8043                      else
8044                        {
8045                          if (((word >> 29) & 0x1) == 0)
8046                            {
8047                              if (((word >> 30) & 0x1) == 0)
8048                                {
8049                                  if (((word >> 21) & 0x1) == 0)
8050                                    {
8051                                      /* 33222222222211111111110000000000
8052                                         10987654321098765432109876543210
8053                                         xxxxxxxxxxxxxxx0xxxxx0xx1111100x
8054                                         fmadd.  */
8055                                      return 651;
8056                                    }
8057                                  else
8058                                    {
8059                                      /* 33222222222211111111110000000000
8060                                         10987654321098765432109876543210
8061                                         xxxxxxxxxxxxxxx0xxxxx1xx1111100x
8062                                         fnmadd.  */
8063                                      return 653;
8064                                    }
8065                                }
8066                              else
8067                                {
8068                                  if (((word >> 10) & 0x1) == 0)
8069                                    {
8070                                      if (((word >> 13) & 0x1) == 0)
8071                                        {
8072                                          if (((word >> 14) & 0x1) == 0)
8073                                            {
8074                                              /* 33222222222211111111110000000000
8075                                                 10987654321098765432109876543210
8076                                                 xxxxxxxxxx0xx000xxxxxxxx1111101x
8077                                                 fmla.  */
8078                                              return 355;
8079                                            }
8080                                          else
8081                                            {
8082                                              /* 33222222222211111111110000000000
8083                                                 10987654321098765432109876543210
8084                                                 xxxxxxxxxx0xx010xxxxxxxx1111101x
8085                                                 fmls.  */
8086                                              return 356;
8087                                            }
8088                                        }
8089                                      else
8090                                        {
8091                                          if (((word >> 14) & 0x1) == 0)
8092                                            {
8093                                              /* 33222222222211111111110000000000
8094                                                 10987654321098765432109876543210
8095                                                 xxxxxxxxxx0xx100xxxxxxxx1111101x
8096                                                 sqdmlal.  */
8097                                              return 350;
8098                                            }
8099                                          else
8100                                            {
8101                                              /* 33222222222211111111110000000000
8102                                                 10987654321098765432109876543210
8103                                                 xxxxxxxxxx0xx110xxxxxxxx1111101x
8104                                                 sqdmlsl.  */
8105                                              return 351;
8106                                            }
8107                                        }
8108                                    }
8109                                  else
8110                                    {
8111                                      if (((word >> 12) & 0x1) == 0)
8112                                        {
8113                                          if (((word >> 13) & 0x1) == 0)
8114                                            {
8115                                              /* 33222222222211111111110000000000
8116                                                 10987654321098765432109876543210
8117                                                 xxxxxxxxxx1x00x0xxxxxxxx1111101x
8118                                                 sshr.  */
8119                                              return 477;
8120                                            }
8121                                          else
8122                                            {
8123                                              /* 33222222222211111111110000000000
8124                                                 10987654321098765432109876543210
8125                                                 xxxxxxxxxx1x01x0xxxxxxxx1111101x
8126                                                 srshr.  */
8127                                              return 479;
8128                                            }
8129                                        }
8130                                      else
8131                                        {
8132                                          if (((word >> 13) & 0x1) == 0)
8133                                            {
8134                                              if (((word >> 14) & 0x1) == 0)
8135                                                {
8136                                                  /* 33222222222211111111110000000000
8137                                                     10987654321098765432109876543210
8138                                                     xxxxxxxxxx1x1000xxxxxxxx1111101x
8139                                                     ssra.  */
8140                                                  return 478;
8141                                                }
8142                                              else
8143                                                {
8144                                                  /* 33222222222211111111110000000000
8145                                                     10987654321098765432109876543210
8146                                                     xxxxxxxxxx1x1010xxxxxxxx1111101x
8147                                                     shl.  */
8148                                                  return 481;
8149                                                }
8150                                            }
8151                                          else
8152                                            {
8153                                              if (((word >> 14) & 0x1) == 0)
8154                                                {
8155                                                  /* 33222222222211111111110000000000
8156                                                     10987654321098765432109876543210
8157                                                     xxxxxxxxxx1x1100xxxxxxxx1111101x
8158                                                     srsra.  */
8159                                                  return 480;
8160                                                }
8161                                              else
8162                                                {
8163                                                  /* 33222222222211111111110000000000
8164                                                     10987654321098765432109876543210
8165                                                     xxxxxxxxxx1x1110xxxxxxxx1111101x
8166                                                     sqshl.  */
8167                                                  return 482;
8168                                                }
8169                                            }
8170                                        }
8171                                    }
8172                                }
8173                            }
8174                          else
8175                            {
8176                              if (((word >> 12) & 0x1) == 0)
8177                                {
8178                                  if (((word >> 13) & 0x1) == 0)
8179                                    {
8180                                      if (((word >> 14) & 0x1) == 0)
8181                                        {
8182                                          /* 33222222222211111111110000000000
8183                                             10987654321098765432109876543210
8184                                             xxxxxxxxxxxx0000xxxxxxxx111111xx
8185                                             ushr.  */
8186                                          return 487;
8187                                        }
8188                                      else
8189                                        {
8190                                          /* 33222222222211111111110000000000
8191                                             10987654321098765432109876543210
8192                                             xxxxxxxxxxxx0010xxxxxxxx111111xx
8193                                             sri.  */
8194                                          return 491;
8195                                        }
8196                                    }
8197                                  else
8198                                    {
8199                                      if (((word >> 14) & 0x1) == 0)
8200                                        {
8201                                          /* 33222222222211111111110000000000
8202                                             10987654321098765432109876543210
8203                                             xxxxxxxxxxxx0100xxxxxxxx111111xx
8204                                             urshr.  */
8205                                          return 489;
8206                                        }
8207                                      else
8208                                        {
8209                                          /* 33222222222211111111110000000000
8210                                             10987654321098765432109876543210
8211                                             xxxxxxxxxxxx0110xxxxxxxx111111xx
8212                                             sqshlu.  */
8213                                          return 493;
8214                                        }
8215                                    }
8216                                }
8217                              else
8218                                {
8219                                  if (((word >> 13) & 0x1) == 0)
8220                                    {
8221                                      if (((word >> 14) & 0x1) == 0)
8222                                        {
8223                                          /* 33222222222211111111110000000000
8224                                             10987654321098765432109876543210
8225                                             xxxxxxxxxxxx1000xxxxxxxx111111xx
8226                                             usra.  */
8227                                          return 488;
8228                                        }
8229                                      else
8230                                        {
8231                                          /* 33222222222211111111110000000000
8232                                             10987654321098765432109876543210
8233                                             xxxxxxxxxxxx1010xxxxxxxx111111xx
8234                                             sli.  */
8235                                          return 492;
8236                                        }
8237                                    }
8238                                  else
8239                                    {
8240                                      if (((word >> 14) & 0x1) == 0)
8241                                        {
8242                                          /* 33222222222211111111110000000000
8243                                             10987654321098765432109876543210
8244                                             xxxxxxxxxxxx1100xxxxxxxx111111xx
8245                                             ursra.  */
8246                                          return 490;
8247                                        }
8248                                      else
8249                                        {
8250                                          /* 33222222222211111111110000000000
8251                                             10987654321098765432109876543210
8252                                             xxxxxxxxxxxx1110xxxxxxxx111111xx
8253                                             uqshl.  */
8254                                          return 494;
8255                                        }
8256                                    }
8257                                }
8258                            }
8259                        }
8260                    }
8261                  else
8262                    {
8263                      if (((word >> 28) & 0x1) == 0)
8264                        {
8265                          if (((word >> 10) & 0x1) == 0)
8266                            {
8267                              if (((word >> 12) & 0x1) == 0)
8268                                {
8269                                  if (((word >> 13) & 0x1) == 0)
8270                                    {
8271                                      if (((word >> 14) & 0x1) == 0)
8272                                        {
8273                                          /* 33222222222211111111110000000000
8274                                             10987654321098765432109876543210
8275                                             xxxxxxxxxx0x0001xxxxxxxx11110xxx
8276                                             mul.  */
8277                                          return 100;
8278                                        }
8279                                      else
8280                                        {
8281                                          /* 33222222222211111111110000000000
8282                                             10987654321098765432109876543210
8283                                             xxxxxxxxxx0x0011xxxxxxxx11110xxx
8284                                             sqdmulh.  */
8285                                          return 105;
8286                                        }
8287                                    }
8288                                  else
8289                                    {
8290                                      if (((word >> 29) & 0x1) == 0)
8291                                        {
8292                                          if (((word >> 30) & 0x1) == 0)
8293                                            {
8294                                              /* 33222222222211111111110000000000
8295                                                 10987654321098765432109876543210
8296                                                 xxxxxxxxxx0x01x1xxxxxxxx1111000x
8297                                                 smull.  */
8298                                              return 101;
8299                                            }
8300                                          else
8301                                            {
8302                                              /* 33222222222211111111110000000000
8303                                                 10987654321098765432109876543210
8304                                                 xxxxxxxxxx0x01x1xxxxxxxx1111001x
8305                                                 smull2.  */
8306                                              return 102;
8307                                            }
8308                                        }
8309                                      else
8310                                        {
8311                                          if (((word >> 30) & 0x1) == 0)
8312                                            {
8313                                              /* 33222222222211111111110000000000
8314                                                 10987654321098765432109876543210
8315                                                 xxxxxxxxxx0x01x1xxxxxxxx1111010x
8316                                                 umull.  */
8317                                              return 116;
8318                                            }
8319                                          else
8320                                            {
8321                                              /* 33222222222211111111110000000000
8322                                                 10987654321098765432109876543210
8323                                                 xxxxxxxxxx0x01x1xxxxxxxx1111011x
8324                                                 umull2.  */
8325                                              return 117;
8326                                            }
8327                                        }
8328                                    }
8329                                }
8330                              else
8331                                {
8332                                  if (((word >> 13) & 0x1) == 0)
8333                                    {
8334                                      if (((word >> 14) & 0x1) == 0)
8335                                        {
8336                                          if (((word >> 29) & 0x1) == 0)
8337                                            {
8338                                              /* 33222222222211111111110000000000
8339                                                 10987654321098765432109876543210
8340                                                 xxxxxxxxxx0x1001xxxxxxxx111100xx
8341                                                 fmul.  */
8342                                              return 109;
8343                                            }
8344                                          else
8345                                            {
8346                                              /* 33222222222211111111110000000000
8347                                                 10987654321098765432109876543210
8348                                                 xxxxxxxxxx0x1001xxxxxxxx111101xx
8349                                                 fmulx.  */
8350                                              return 118;
8351                                            }
8352                                        }
8353                                      else
8354                                        {
8355                                          if (((word >> 29) & 0x1) == 0)
8356                                            {
8357                                              /* 33222222222211111111110000000000
8358                                                 10987654321098765432109876543210
8359                                                 xxxxxxxxxx0x1011xxxxxxxx111100xx
8360                                                 sqrdmulh.  */
8361                                              return 106;
8362                                            }
8363                                          else
8364                                            {
8365                                              /* 33222222222211111111110000000000
8366                                                 10987654321098765432109876543210
8367                                                 xxxxxxxxxx0x1011xxxxxxxx111101xx
8368                                                 sqrdmlah.  */
8369                                              return 119;
8370                                            }
8371                                        }
8372                                    }
8373                                  else
8374                                    {
8375                                      if (((word >> 14) & 0x1) == 0)
8376                                        {
8377                                          if (((word >> 30) & 0x1) == 0)
8378                                            {
8379                                              /* 33222222222211111111110000000000
8380                                                 10987654321098765432109876543210
8381                                                 xxxxxxxxxx0x1101xxxxxxxx11110x0x
8382                                                 sqdmull.  */
8383                                              return 103;
8384                                            }
8385                                          else
8386                                            {
8387                                              /* 33222222222211111111110000000000
8388                                                 10987654321098765432109876543210
8389                                                 xxxxxxxxxx0x1101xxxxxxxx11110x1x
8390                                                 sqdmull2.  */
8391                                              return 104;
8392                                            }
8393                                        }
8394                                      else
8395                                        {
8396                                          /* 33222222222211111111110000000000
8397                                             10987654321098765432109876543210
8398                                             xxxxxxxxxx0x1111xxxxxxxx11110xxx
8399                                             sqrdmlsh.  */
8400                                          return 120;
8401                                        }
8402                                    }
8403                                }
8404                            }
8405                          else
8406                            {
8407                              if (((word >> 11) & 0x1) == 0)
8408                                {
8409                                  if (((word >> 14) & 0x1) == 0)
8410                                    {
8411                                      if (((word >> 12) & 0x1) == 0)
8412                                        {
8413                                          if (((word >> 29) & 0x1) == 0)
8414                                            {
8415                                              /* 33222222222211111111110000000000
8416                                                 10987654321098765432109876543210
8417                                                 xxxxxxxxxx100x01xxxxxxxx111100xx
8418                                                 movi.  */
8419                                              return 124;
8420                                            }
8421                                          else
8422                                            {
8423                                              /* 33222222222211111111110000000000
8424                                                 10987654321098765432109876543210
8425                                                 xxxxxxxxxx100x01xxxxxxxx111101xx
8426                                                 mvni.  */
8427                                              return 131;
8428                                            }
8429                                        }
8430                                      else
8431                                        {
8432                                          if (((word >> 29) & 0x1) == 0)
8433                                            {
8434                                              /* 33222222222211111111110000000000
8435                                                 10987654321098765432109876543210
8436                                                 xxxxxxxxxx101x01xxxxxxxx111100xx
8437                                                 orr.  */
8438                                              return 125;
8439                                            }
8440                                          else
8441                                            {
8442                                              /* 33222222222211111111110000000000
8443                                                 10987654321098765432109876543210
8444                                                 xxxxxxxxxx101x01xxxxxxxx111101xx
8445                                                 bic.  */
8446                                              return 132;
8447                                            }
8448                                        }
8449                                    }
8450                                  else
8451                                    {
8452                                      if (((word >> 13) & 0x1) == 0)
8453                                        {
8454                                          if (((word >> 29) & 0x1) == 0)
8455                                            {
8456                                              /* 33222222222211111111110000000000
8457                                                 10987654321098765432109876543210
8458                                                 xxxxxxxxxx10x011xxxxxxxx111100xx
8459                                                 movi.  */
8460                                              return 126;
8461                                            }
8462                                          else
8463                                            {
8464                                              /* 33222222222211111111110000000000
8465                                                 10987654321098765432109876543210
8466                                                 xxxxxxxxxx10x011xxxxxxxx111101xx
8467                                                 mvni.  */
8468                                              return 133;
8469                                            }
8470                                        }
8471                                      else
8472                                        {
8473                                          if (((word >> 12) & 0x1) == 0)
8474                                            {
8475                                              if (((word >> 29) & 0x1) == 0)
8476                                                {
8477                                                  /* 33222222222211111111110000000000
8478                                                     10987654321098765432109876543210
8479                                                     xxxxxxxxxx100111xxxxxxxx111100xx
8480                                                     movi.  */
8481                                                  return 127;
8482                                                }
8483                                              else
8484                                                {
8485                                                  /* 33222222222211111111110000000000
8486                                                     10987654321098765432109876543210
8487                                                     xxxxxxxxxx100111xxxxxxxx111101xx
8488                                                     movi.  */
8489                                                  return 134;
8490                                                }
8491                                            }
8492                                          else
8493                                            {
8494                                              if (((word >> 29) & 0x1) == 0)
8495                                                {
8496                                                  /* 33222222222211111111110000000000
8497                                                     10987654321098765432109876543210
8498                                                     xxxxxxxxxx101111xxxxxxxx111100xx
8499                                                     fmov.  */
8500                                                  return 128;
8501                                                }
8502                                              else
8503                                                {
8504                                                  /* 33222222222211111111110000000000
8505                                                     10987654321098765432109876543210
8506                                                     xxxxxxxxxx101111xxxxxxxx111101xx
8507                                                     fmov.  */
8508                                                  return 136;
8509                                                }
8510                                            }
8511                                        }
8512                                    }
8513                                }
8514                              else
8515                                {
8516                                  if (((word >> 12) & 0x1) == 0)
8517                                    {
8518                                      if (((word >> 29) & 0x1) == 0)
8519                                        {
8520                                          if (((word >> 30) & 0x1) == 0)
8521                                            {
8522                                              /* 33222222222211111111110000000000
8523                                                 10987654321098765432109876543210
8524                                                 xxxxxxxxxx110xx1xxxxxxxx1111000x
8525                                                 rshrn.  */
8526                                              return 311;
8527                                            }
8528                                          else
8529                                            {
8530                                              /* 33222222222211111111110000000000
8531                                                 10987654321098765432109876543210
8532                                                 xxxxxxxxxx110xx1xxxxxxxx1111001x
8533                                                 rshrn2.  */
8534                                              return 312;
8535                                            }
8536                                        }
8537                                      else
8538                                        {
8539                                          if (((word >> 30) & 0x1) == 0)
8540                                            {
8541                                              /* 33222222222211111111110000000000
8542                                                 10987654321098765432109876543210
8543                                                 xxxxxxxxxx110xx1xxxxxxxx1111010x
8544                                                 sqrshrun.  */
8545                                              return 333;
8546                                            }
8547                                          else
8548                                            {
8549                                              /* 33222222222211111111110000000000
8550                                                 10987654321098765432109876543210
8551                                                 xxxxxxxxxx110xx1xxxxxxxx1111011x
8552                                                 sqrshrun2.  */
8553                                              return 334;
8554                                            }
8555                                        }
8556                                    }
8557                                  else
8558                                    {
8559                                      if (((word >> 13) & 0x1) == 0)
8560                                        {
8561                                          if (((word >> 29) & 0x1) == 0)
8562                                            {
8563                                              if (((word >> 30) & 0x1) == 0)
8564                                                {
8565                                                  /* 33222222222211111111110000000000
8566                                                     10987654321098765432109876543210
8567                                                     xxxxxxxxxx1110x1xxxxxxxx1111000x
8568                                                     sqrshrn.  */
8569                                                  return 315;
8570                                                }
8571                                              else
8572                                                {
8573                                                  /* 33222222222211111111110000000000
8574                                                     10987654321098765432109876543210
8575                                                     xxxxxxxxxx1110x1xxxxxxxx1111001x
8576                                                     sqrshrn2.  */
8577                                                  return 316;
8578                                                }
8579                                            }
8580                                          else
8581                                            {
8582                                              if (((word >> 30) & 0x1) == 0)
8583                                                {
8584                                                  /* 33222222222211111111110000000000
8585                                                     10987654321098765432109876543210
8586                                                     xxxxxxxxxx1110x1xxxxxxxx1111010x
8587                                                     uqrshrn.  */
8588                                                  return 337;
8589                                                }
8590                                              else
8591                                                {
8592                                                  /* 33222222222211111111110000000000
8593                                                     10987654321098765432109876543210
8594                                                     xxxxxxxxxx1110x1xxxxxxxx1111011x
8595                                                     uqrshrn2.  */
8596                                                  return 338;
8597                                                }
8598                                            }
8599                                        }
8600                                      else
8601                                        {
8602                                          if (((word >> 29) & 0x1) == 0)
8603                                            {
8604                                              /* 33222222222211111111110000000000
8605                                                 10987654321098765432109876543210
8606                                                 xxxxxxxxxx1111x1xxxxxxxx111100xx
8607                                                 fcvtzs.  */
8608                                              return 322;
8609                                            }
8610                                          else
8611                                            {
8612                                              /* 33222222222211111111110000000000
8613                                                 10987654321098765432109876543210
8614                                                 xxxxxxxxxx1111x1xxxxxxxx111101xx
8615                                                 fcvtzu.  */
8616                                              return 344;
8617                                            }
8618                                        }
8619                                    }
8620                                }
8621                            }
8622                        }
8623                      else
8624                        {
8625                          if (((word >> 29) & 0x1) == 0)
8626                            {
8627                              if (((word >> 30) & 0x1) == 0)
8628                                {
8629                                  if (((word >> 21) & 0x1) == 0)
8630                                    {
8631                                      /* 33222222222211111111110000000000
8632                                         10987654321098765432109876543210
8633                                         xxxxxxxxxxxxxxx1xxxxx0xx1111100x
8634                                         fmsub.  */
8635                                      return 652;
8636                                    }
8637                                  else
8638                                    {
8639                                      /* 33222222222211111111110000000000
8640                                         10987654321098765432109876543210
8641                                         xxxxxxxxxxxxxxx1xxxxx1xx1111100x
8642                                         fnmsub.  */
8643                                      return 654;
8644                                    }
8645                                }
8646                              else
8647                                {
8648                                  if (((word >> 10) & 0x1) == 0)
8649                                    {
8650                                      if (((word >> 12) & 0x1) == 0)
8651                                        {
8652                                          /* 33222222222211111111110000000000
8653                                             10987654321098765432109876543210
8654                                             xxxxxxxxxx0x0xx1xxxxxxxx1111101x
8655                                             sqdmulh.  */
8656                                          return 353;
8657                                        }
8658                                      else
8659                                        {
8660                                          if (((word >> 13) & 0x1) == 0)
8661                                            {
8662                                              if (((word >> 14) & 0x1) == 0)
8663                                                {
8664                                                  /* 33222222222211111111110000000000
8665                                                     10987654321098765432109876543210
8666                                                     xxxxxxxxxx0x1001xxxxxxxx1111101x
8667                                                     fmul.  */
8668                                                  return 357;
8669                                                }
8670                                              else
8671                                                {
8672                                                  /* 33222222222211111111110000000000
8673                                                     10987654321098765432109876543210
8674                                                     xxxxxxxxxx0x1011xxxxxxxx1111101x
8675                                                     sqrdmulh.  */
8676                                                  return 354;
8677                                                }
8678                                            }
8679                                          else
8680                                            {
8681                                              /* 33222222222211111111110000000000
8682                                                 10987654321098765432109876543210
8683                                                 xxxxxxxxxx0x11x1xxxxxxxx1111101x
8684                                                 sqdmull.  */
8685                                              return 352;
8686                                            }
8687                                        }
8688                                    }
8689                                  else
8690                                    {
8691                                      if (((word >> 11) & 0x1) == 0)
8692                                        {
8693                                          if (((word >> 12) & 0x1) == 0)
8694                                            {
8695                                              /* 33222222222211111111110000000000
8696                                                 10987654321098765432109876543210
8697                                                 xxxxxxxxxx100xx1xxxxxxxx1111101x
8698                                                 scvtf.  */
8699                                              return 485;
8700                                            }
8701                                          else
8702                                            {
8703                                              /* 33222222222211111111110000000000
8704                                                 10987654321098765432109876543210
8705                                                 xxxxxxxxxx101xx1xxxxxxxx1111101x
8706                                                 sqshrn.  */
8707                                              return 483;
8708                                            }
8709                                        }
8710                                      else
8711                                        {
8712                                          if (((word >> 13) & 0x1) == 0)
8713                                            {
8714                                              /* 33222222222211111111110000000000
8715                                                 10987654321098765432109876543210
8716                                                 xxxxxxxxxx11x0x1xxxxxxxx1111101x
8717                                                 sqrshrn.  */
8718                                              return 484;
8719                                            }
8720                                          else
8721                                            {
8722                                              /* 33222222222211111111110000000000
8723                                                 10987654321098765432109876543210
8724                                                 xxxxxxxxxx11x1x1xxxxxxxx1111101x
8725                                                 fcvtzs.  */
8726                                              return 486;
8727                                            }
8728                                        }
8729                                    }
8730                                }
8731                            }
8732                          else
8733                            {
8734                              if (((word >> 10) & 0x1) == 0)
8735                                {
8736                                  if (((word >> 13) & 0x1) == 0)
8737                                    {
8738                                      if (((word >> 14) & 0x1) == 0)
8739                                        {
8740                                          /* 33222222222211111111110000000000
8741                                             10987654321098765432109876543210
8742                                             xxxxxxxxxx0xx001xxxxxxxx111111xx
8743                                             fmulx.  */
8744                                          return 358;
8745                                        }
8746                                      else
8747                                        {
8748                                          /* 33222222222211111111110000000000
8749                                             10987654321098765432109876543210
8750                                             xxxxxxxxxx0xx011xxxxxxxx111111xx
8751                                             sqrdmlah.  */
8752                                          return 359;
8753                                        }
8754                                    }
8755                                  else
8756                                    {
8757                                      /* 33222222222211111111110000000000
8758                                         10987654321098765432109876543210
8759                                         xxxxxxxxxx0xx1x1xxxxxxxx111111xx
8760                                         sqrdmlsh.  */
8761                                      return 360;
8762                                    }
8763                                }
8764                              else
8765                                {
8766                                  if (((word >> 11) & 0x1) == 0)
8767                                    {
8768                                      if (((word >> 12) & 0x1) == 0)
8769                                        {
8770                                          if (((word >> 13) & 0x1) == 0)
8771                                            {
8772                                              /* 33222222222211111111110000000000
8773                                                 10987654321098765432109876543210
8774                                                 xxxxxxxxxx1000x1xxxxxxxx111111xx
8775                                                 sqshrun.  */
8776                                              return 495;
8777                                            }
8778                                          else
8779                                            {
8780                                              /* 33222222222211111111110000000000
8781                                                 10987654321098765432109876543210
8782                                                 xxxxxxxxxx1001x1xxxxxxxx111111xx
8783                                                 ucvtf.  */
8784                                              return 499;
8785                                            }
8786                                        }
8787                                      else
8788                                        {
8789                                          /* 33222222222211111111110000000000
8790                                             10987654321098765432109876543210
8791                                             xxxxxxxxxx101xx1xxxxxxxx111111xx
8792                                             uqshrn.  */
8793                                          return 497;
8794                                        }
8795                                    }
8796                                  else
8797                                    {
8798                                      if (((word >> 12) & 0x1) == 0)
8799                                        {
8800                                          /* 33222222222211111111110000000000
8801                                             10987654321098765432109876543210
8802                                             xxxxxxxxxx110xx1xxxxxxxx111111xx
8803                                             sqrshrun.  */
8804                                          return 496;
8805                                        }
8806                                      else
8807                                        {
8808                                          if (((word >> 13) & 0x1) == 0)
8809                                            {
8810                                              /* 33222222222211111111110000000000
8811                                                 10987654321098765432109876543210
8812                                                 xxxxxxxxxx1110x1xxxxxxxx111111xx
8813                                                 uqrshrn.  */
8814                                              return 498;
8815                                            }
8816                                          else
8817                                            {
8818                                              /* 33222222222211111111110000000000
8819                                                 10987654321098765432109876543210
8820                                                 xxxxxxxxxx1111x1xxxxxxxx111111xx
8821                                                 fcvtzu.  */
8822                                              return 500;
8823                                            }
8824                                        }
8825                                    }
8826                                }
8827                            }
8828                        }
8829                    }
8830                }
8831            }
8832        }
8833    }
8834}
8835
8836/* Lookup opcode WORD in the opcode table.  N.B. all alias
8837   opcodes are ignored here.  */
8838
8839const aarch64_opcode *
8840aarch64_opcode_lookup (uint32_t word)
8841{
8842  return aarch64_opcode_table + aarch64_opcode_lookup_1 (word);
8843}
8844
8845const aarch64_opcode *
8846aarch64_find_next_opcode (const aarch64_opcode *opcode)
8847{
8848  /* Use the index as the key to locate the next opcode.  */
8849  int key = opcode - aarch64_opcode_table;
8850  int value;
8851  switch (key)
8852    {
8853    case 741: value = 745; break;	/* stnp --> stp.  */
8854    case 745: return NULL;		/* stp --> NULL.  */
8855    case 739: value = 740; break;	/* stllrb --> stllrh.  */
8856    case 740: return NULL;		/* stllrh --> NULL.  */
8857    case 742: value = 746; break;	/* ldnp --> ldp.  */
8858    case 746: return NULL;		/* ldp --> NULL.  */
8859    case 957: value = 958; break;	/* msr --> hint.  */
8860    case 958: value = 965; break;	/* hint --> clrex.  */
8861    case 965: value = 966; break;	/* clrex --> dsb.  */
8862    case 966: value = 967; break;	/* dsb --> dmb.  */
8863    case 967: value = 968; break;	/* dmb --> isb.  */
8864    case 968: value = 969; break;	/* isb --> sys.  */
8865    case 969: value = 974; break;	/* sys --> msr.  */
8866    case 974: return NULL;		/* msr --> NULL.  */
8867    case 975: value = 976; break;	/* sysl --> mrs.  */
8868    case 976: return NULL;		/* mrs --> NULL.  */
8869    case 361: value = 362; break;	/* st4 --> st1.  */
8870    case 362: value = 363; break;	/* st1 --> st2.  */
8871    case 363: value = 364; break;	/* st2 --> st3.  */
8872    case 364: return NULL;		/* st3 --> NULL.  */
8873    case 369: value = 370; break;	/* st4 --> st1.  */
8874    case 370: value = 371; break;	/* st1 --> st2.  */
8875    case 371: value = 372; break;	/* st2 --> st3.  */
8876    case 372: return NULL;		/* st3 --> NULL.  */
8877    case 365: value = 366; break;	/* ld4 --> ld1.  */
8878    case 366: value = 367; break;	/* ld1 --> ld2.  */
8879    case 367: value = 368; break;	/* ld2 --> ld3.  */
8880    case 368: return NULL;		/* ld3 --> NULL.  */
8881    case 381: value = 383; break;	/* ld1 --> ld1r.  */
8882    case 383: return NULL;		/* ld1r --> NULL.  */
8883    case 385: value = 387; break;	/* ld2 --> ld2r.  */
8884    case 387: return NULL;		/* ld2r --> NULL.  */
8885    case 382: value = 384; break;	/* ld3 --> ld3r.  */
8886    case 384: return NULL;		/* ld3r --> NULL.  */
8887    case 386: value = 388; break;	/* ld4 --> ld4r.  */
8888    case 388: return NULL;		/* ld4r --> NULL.  */
8889    case 373: value = 374; break;	/* ld4 --> ld1.  */
8890    case 374: value = 375; break;	/* ld1 --> ld2.  */
8891    case 375: value = 376; break;	/* ld2 --> ld3.  */
8892    case 376: return NULL;		/* ld3 --> NULL.  */
8893    case 393: value = 395; break;	/* ld1 --> ld1r.  */
8894    case 395: return NULL;		/* ld1r --> NULL.  */
8895    case 394: value = 396; break;	/* ld3 --> ld3r.  */
8896    case 396: return NULL;		/* ld3r --> NULL.  */
8897    case 397: value = 399; break;	/* ld2 --> ld2r.  */
8898    case 399: return NULL;		/* ld2r --> NULL.  */
8899    case 398: value = 400; break;	/* ld4 --> ld4r.  */
8900    case 400: return NULL;		/* ld4r --> NULL.  */
8901    case 122: value = 303; break;	/* movi --> sshr.  */
8902    case 303: value = 305; break;	/* sshr --> srshr.  */
8903    case 305: return NULL;		/* srshr --> NULL.  */
8904    case 129: value = 323; break;	/* mvni --> ushr.  */
8905    case 323: value = 325; break;	/* ushr --> urshr.  */
8906    case 325: value = 327; break;	/* urshr --> sri.  */
8907    case 327: value = 329; break;	/* sri --> sqshlu.  */
8908    case 329: return NULL;		/* sqshlu --> NULL.  */
8909    case 123: value = 304; break;	/* orr --> ssra.  */
8910    case 304: value = 306; break;	/* ssra --> srsra.  */
8911    case 306: value = 307; break;	/* srsra --> shl.  */
8912    case 307: value = 308; break;	/* shl --> sqshl.  */
8913    case 308: return NULL;		/* sqshl --> NULL.  */
8914    case 130: value = 324; break;	/* bic --> usra.  */
8915    case 324: value = 326; break;	/* usra --> ursra.  */
8916    case 326: value = 328; break;	/* ursra --> sli.  */
8917    case 328: value = 330; break;	/* sli --> uqshl.  */
8918    case 330: return NULL;		/* uqshl --> NULL.  */
8919    case 124: value = 309; break;	/* movi --> shrn.  */
8920    case 309: value = 310; break;	/* shrn --> shrn2.  */
8921    case 310: value = 317; break;	/* shrn2 --> sshll.  */
8922    case 317: value = 319; break;	/* sshll --> sshll2.  */
8923    case 319: return NULL;		/* sshll2 --> NULL.  */
8924    case 131: value = 331; break;	/* mvni --> sqshrun.  */
8925    case 331: value = 332; break;	/* sqshrun --> sqshrun2.  */
8926    case 332: value = 339; break;	/* sqshrun2 --> ushll.  */
8927    case 339: value = 341; break;	/* ushll --> ushll2.  */
8928    case 341: return NULL;		/* ushll2 --> NULL.  */
8929    case 125: value = 313; break;	/* orr --> sqshrn.  */
8930    case 313: value = 314; break;	/* sqshrn --> sqshrn2.  */
8931    case 314: return NULL;		/* sqshrn2 --> NULL.  */
8932    case 132: value = 335; break;	/* bic --> uqshrn.  */
8933    case 335: value = 336; break;	/* uqshrn --> uqshrn2.  */
8934    case 336: return NULL;		/* uqshrn2 --> NULL.  */
8935    case 127: value = 321; break;	/* movi --> scvtf.  */
8936    case 321: return NULL;		/* scvtf --> NULL.  */
8937    case 134: value = 135; break;	/* movi --> movi.  */
8938    case 135: value = 343; break;	/* movi --> ucvtf.  */
8939    case 343: return NULL;		/* ucvtf --> NULL.  */
8940    default: return NULL;
8941    }
8942
8943  return aarch64_opcode_table + value;
8944}
8945
8946const aarch64_opcode *
8947aarch64_find_alias_opcode (const aarch64_opcode *opcode)
8948{
8949  /* Use the index as the key to locate the alias opcode.  */
8950  int key = opcode - aarch64_opcode_table;
8951  int value;
8952  switch (key)
8953    {
8954    case 2: value = 3; break;	/* sbc --> ngc.  */
8955    case 4: value = 5; break;	/* sbcs --> ngcs.  */
8956    case 7: value = 8; break;	/* adds --> cmn.  */
8957    case 10: value = 11; break;	/* subs --> cmp.  */
8958    case 12: value = 13; break;	/* add --> mov.  */
8959    case 14: value = 15; break;	/* adds --> cmn.  */
8960    case 17: value = 18; break;	/* subs --> cmp.  */
8961    case 20: value = 21; break;	/* adds --> cmn.  */
8962    case 22: value = 23; break;	/* sub --> neg.  */
8963    case 24: value = 26; break;	/* subs --> negs.  */
8964    case 140: value = 141; break;	/* umov --> mov.  */
8965    case 142: value = 143; break;	/* ins --> mov.  */
8966    case 144: value = 145; break;	/* ins --> mov.  */
8967    case 205: value = 206; break;	/* not --> mvn.  */
8968    case 260: value = 261; break;	/* orr --> mov.  */
8969    case 317: value = 318; break;	/* sshll --> sxtl.  */
8970    case 319: value = 320; break;	/* sshll2 --> sxtl2.  */
8971    case 339: value = 340; break;	/* ushll --> uxtl.  */
8972    case 341: value = 342; break;	/* ushll2 --> uxtl2.  */
8973    case 436: value = 437; break;	/* dup --> mov.  */
8974    case 501: value = 506; break;	/* sbfm --> sxtw.  */
8975    case 508: value = 510; break;	/* bfm --> bfxil.  */
8976    case 511: value = 515; break;	/* ubfm --> uxth.  */
8977    case 533: value = 535; break;	/* csinc --> cset.  */
8978    case 536: value = 538; break;	/* csinv --> csetm.  */
8979    case 539: value = 540; break;	/* csneg --> cneg.  */
8980    case 564: value = 565; break;	/* lslv --> lsl.  */
8981    case 566: value = 567; break;	/* lsrv --> lsr.  */
8982    case 568: value = 569; break;	/* asrv --> asr.  */
8983    case 570: value = 571; break;	/* rorv --> ror.  */
8984    case 580: value = 581; break;	/* madd --> mul.  */
8985    case 582: value = 583; break;	/* msub --> mneg.  */
8986    case 584: value = 585; break;	/* smaddl --> smull.  */
8987    case 586: value = 587; break;	/* smsubl --> smnegl.  */
8988    case 589: value = 590; break;	/* umaddl --> umull.  */
8989    case 591: value = 592; break;	/* umsubl --> umnegl.  */
8990    case 602: value = 603; break;	/* extr --> ror.  */
8991    case 759: value = 760; break;	/* and --> bic.  */
8992    case 761: value = 762; break;	/* orr --> mov.  */
8993    case 764: value = 765; break;	/* ands --> tst.  */
8994    case 768: value = 770; break;	/* orr --> uxtw.  */
8995    case 771: value = 772; break;	/* orn --> mvn.  */
8996    case 775: value = 776; break;	/* ands --> tst.  */
8997    case 806: value = 902; break;	/* ldaddb --> staddb.  */
8998    case 807: value = 903; break;	/* ldaddh --> staddh.  */
8999    case 808: value = 904; break;	/* ldadd --> stadd.  */
9000    case 810: value = 905; break;	/* ldaddlb --> staddlb.  */
9001    case 813: value = 906; break;	/* ldaddlh --> staddlh.  */
9002    case 816: value = 907; break;	/* ldaddl --> staddl.  */
9003    case 818: value = 908; break;	/* ldclrb --> stclrb.  */
9004    case 819: value = 909; break;	/* ldclrh --> stclrh.  */
9005    case 820: value = 910; break;	/* ldclr --> stclr.  */
9006    case 822: value = 911; break;	/* ldclrlb --> stclrlb.  */
9007    case 825: value = 912; break;	/* ldclrlh --> stclrlh.  */
9008    case 828: value = 913; break;	/* ldclrl --> stclrl.  */
9009    case 830: value = 914; break;	/* ldeorb --> steorb.  */
9010    case 831: value = 915; break;	/* ldeorh --> steorh.  */
9011    case 832: value = 916; break;	/* ldeor --> steor.  */
9012    case 834: value = 917; break;	/* ldeorlb --> steorlb.  */
9013    case 837: value = 918; break;	/* ldeorlh --> steorlh.  */
9014    case 840: value = 919; break;	/* ldeorl --> steorl.  */
9015    case 842: value = 920; break;	/* ldsetb --> stsetb.  */
9016    case 843: value = 921; break;	/* ldseth --> stseth.  */
9017    case 844: value = 922; break;	/* ldset --> stset.  */
9018    case 846: value = 923; break;	/* ldsetlb --> stsetlb.  */
9019    case 849: value = 924; break;	/* ldsetlh --> stsetlh.  */
9020    case 852: value = 925; break;	/* ldsetl --> stsetl.  */
9021    case 854: value = 926; break;	/* ldsmaxb --> stsmaxb.  */
9022    case 855: value = 927; break;	/* ldsmaxh --> stsmaxh.  */
9023    case 856: value = 928; break;	/* ldsmax --> stsmax.  */
9024    case 858: value = 929; break;	/* ldsmaxlb --> stsmaxlb.  */
9025    case 861: value = 930; break;	/* ldsmaxlh --> stsmaxlh.  */
9026    case 864: value = 931; break;	/* ldsmaxl --> stsmaxl.  */
9027    case 866: value = 932; break;	/* ldsminb --> stsminb.  */
9028    case 867: value = 933; break;	/* ldsminh --> stsminh.  */
9029    case 868: value = 934; break;	/* ldsmin --> stsmin.  */
9030    case 870: value = 935; break;	/* ldsminlb --> stsminlb.  */
9031    case 873: value = 936; break;	/* ldsminlh --> stsminlh.  */
9032    case 876: value = 937; break;	/* ldsminl --> stsminl.  */
9033    case 878: value = 938; break;	/* ldumaxb --> stumaxb.  */
9034    case 879: value = 939; break;	/* ldumaxh --> stumaxh.  */
9035    case 880: value = 940; break;	/* ldumax --> stumax.  */
9036    case 882: value = 941; break;	/* ldumaxlb --> stumaxlb.  */
9037    case 885: value = 942; break;	/* ldumaxlh --> stumaxlh.  */
9038    case 888: value = 943; break;	/* ldumaxl --> stumaxl.  */
9039    case 890: value = 944; break;	/* lduminb --> stuminb.  */
9040    case 891: value = 945; break;	/* lduminh --> stuminh.  */
9041    case 892: value = 946; break;	/* ldumin --> stumin.  */
9042    case 894: value = 947; break;	/* lduminlb --> stuminlb.  */
9043    case 897: value = 948; break;	/* lduminlh --> stuminlh.  */
9044    case 900: value = 949; break;	/* lduminl --> stuminl.  */
9045    case 950: value = 951; break;	/* movn --> mov.  */
9046    case 952: value = 953; break;	/* movz --> mov.  */
9047    case 958: value = 964; break;	/* hint --> sevl.  */
9048    case 969: value = 973; break;	/* sys --> tlbi.  */
9049    default: return NULL;
9050    }
9051
9052  return aarch64_opcode_table + value;
9053}
9054
9055const aarch64_opcode *
9056aarch64_find_next_alias_opcode (const aarch64_opcode *opcode)
9057{
9058  /* Use the index as the key to locate the next opcode.  */
9059  int key = opcode - aarch64_opcode_table;
9060  int value;
9061  switch (key)
9062    {
9063    case 26: value = 25; break;	/* negs --> cmp.  */
9064    case 506: value = 505; break;	/* sxtw --> sxth.  */
9065    case 505: value = 504; break;	/* sxth --> sxtb.  */
9066    case 504: value = 507; break;	/* sxtb --> asr.  */
9067    case 507: value = 503; break;	/* asr --> sbfx.  */
9068    case 503: value = 502; break;	/* sbfx --> sbfiz.  */
9069    case 510: value = 509; break;	/* bfxil --> bfi.  */
9070    case 515: value = 514; break;	/* uxth --> uxtb.  */
9071    case 514: value = 517; break;	/* uxtb --> lsr.  */
9072    case 517: value = 516; break;	/* lsr --> lsl.  */
9073    case 516: value = 513; break;	/* lsl --> ubfx.  */
9074    case 513: value = 512; break;	/* ubfx --> ubfiz.  */
9075    case 535: value = 534; break;	/* cset --> cinc.  */
9076    case 538: value = 537; break;	/* csetm --> cinv.  */
9077    case 770: value = 769; break;	/* uxtw --> mov.  */
9078    case 964: value = 963; break;	/* sevl --> sev.  */
9079    case 963: value = 962; break;	/* sev --> wfi.  */
9080    case 962: value = 961; break;	/* wfi --> wfe.  */
9081    case 961: value = 960; break;	/* wfe --> yield.  */
9082    case 960: value = 959; break;	/* yield --> nop.  */
9083    case 973: value = 972; break;	/* tlbi --> ic.  */
9084    case 972: value = 971; break;	/* ic --> dc.  */
9085    case 971: value = 970; break;	/* dc --> at.  */
9086    default: return NULL;
9087    }
9088
9089  return aarch64_opcode_table + value;
9090}
9091
9092int
9093aarch64_extract_operand (const aarch64_operand *self,
9094			   aarch64_opnd_info *info,
9095			   aarch64_insn code, const aarch64_inst *inst)
9096{
9097  /* Use the index as the key.  */
9098  int key = self - aarch64_operands;
9099  switch (key)
9100    {
9101    case 1:
9102    case 2:
9103    case 3:
9104    case 4:
9105    case 5:
9106    case 6:
9107    case 7:
9108    case 9:
9109    case 10:
9110    case 14:
9111    case 15:
9112    case 16:
9113    case 17:
9114    case 19:
9115    case 20:
9116    case 21:
9117    case 22:
9118    case 23:
9119    case 24:
9120    case 25:
9121    case 26:
9122    case 27:
9123    case 35:
9124    case 36:
9125      return aarch64_ext_regno (self, info, code, inst);
9126    case 8:
9127      return aarch64_ext_regrt_sysins (self, info, code, inst);
9128    case 11:
9129      return aarch64_ext_regno_pair (self, info, code, inst);
9130    case 12:
9131      return aarch64_ext_reg_extended (self, info, code, inst);
9132    case 13:
9133      return aarch64_ext_reg_shifted (self, info, code, inst);
9134    case 18:
9135      return aarch64_ext_ft (self, info, code, inst);
9136    case 28:
9137    case 29:
9138    case 30:
9139      return aarch64_ext_reglane (self, info, code, inst);
9140    case 31:
9141      return aarch64_ext_reglist (self, info, code, inst);
9142    case 32:
9143      return aarch64_ext_ldst_reglist (self, info, code, inst);
9144    case 33:
9145      return aarch64_ext_ldst_reglist_r (self, info, code, inst);
9146    case 34:
9147      return aarch64_ext_ldst_elemlist (self, info, code, inst);
9148    case 37:
9149    case 46:
9150    case 47:
9151    case 48:
9152    case 49:
9153    case 50:
9154    case 51:
9155    case 52:
9156    case 53:
9157    case 54:
9158    case 55:
9159    case 56:
9160    case 57:
9161    case 58:
9162    case 66:
9163    case 67:
9164    case 68:
9165    case 69:
9166    case 70:
9167      return aarch64_ext_imm (self, info, code, inst);
9168    case 38:
9169    case 39:
9170      return aarch64_ext_advsimd_imm_shift (self, info, code, inst);
9171    case 40:
9172    case 41:
9173    case 42:
9174      return aarch64_ext_advsimd_imm_modified (self, info, code, inst);
9175    case 43:
9176      return aarch64_ext_shll_imm (self, info, code, inst);
9177    case 59:
9178      return aarch64_ext_limm (self, info, code, inst);
9179    case 60:
9180      return aarch64_ext_aimm (self, info, code, inst);
9181    case 61:
9182      return aarch64_ext_imm_half (self, info, code, inst);
9183    case 62:
9184      return aarch64_ext_fbits (self, info, code, inst);
9185    case 64:
9186    case 65:
9187      return aarch64_ext_cond (self, info, code, inst);
9188    case 71:
9189    case 77:
9190      return aarch64_ext_addr_simple (self, info, code, inst);
9191    case 72:
9192      return aarch64_ext_addr_regoff (self, info, code, inst);
9193    case 73:
9194    case 74:
9195    case 75:
9196      return aarch64_ext_addr_simm (self, info, code, inst);
9197    case 76:
9198      return aarch64_ext_addr_uimm12 (self, info, code, inst);
9199    case 78:
9200      return aarch64_ext_simd_addr_post (self, info, code, inst);
9201    case 79:
9202      return aarch64_ext_sysreg (self, info, code, inst);
9203    case 80:
9204      return aarch64_ext_pstatefield (self, info, code, inst);
9205    case 81:
9206    case 82:
9207    case 83:
9208    case 84:
9209      return aarch64_ext_sysins_op (self, info, code, inst);
9210    case 85:
9211    case 86:
9212      return aarch64_ext_barrier (self, info, code, inst);
9213    case 87:
9214      return aarch64_ext_prfop (self, info, code, inst);
9215    default: assert (0); abort ();
9216    }
9217}
9218