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