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