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