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